//...MF using LaaPackages.Features.Cordonel;
using GenesisCordonelInterface.API;
using Logic.ProductionToProductMapper.Cordonel;
using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Xylem.Common.CommonCore.Configuration;
using Xylem.Common.CommonCore.Consts;
using Xylem.Common.Hardware.Interfaces.Ports.PortCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.Applications.Const;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore;
using Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.Consts;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers;
using Xylem.Common.Hardware.WaterMeter.Genesis.Registers.DataTypes;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Logic.ProductionOrderCore.TestResults;
using Xylem.Common.Logic.SoftwareAccessHelper;
using Xylem.Common.Utils.Logging;
using static Xylem.Common.Hardware.WaterMeter.Genesis.GenesisCore.GenesisMeter;
using Access = Xylem.Common.Hardware.WaterMeter.Genesis.Registers.Access;
using Register = Xylem.Common.Hardware.WaterMeter.Genesis.Registers.Register;

namespace GenesisCordonelInterface.UI.LaatzenAPI_GenesisToolBox
{
    public partial class FrmRegisterStore : Form
    {
        private static readonly NLog.ILogger Logger = NLog.LogManager.GetLogger("GenesisCordonelInterface");
        private readonly InterfaceGCIToLaatzen interfaceToLaatzen = new InterfaceGCIToLaatzen();

        public class regStore
        {
            public String PcbId;
            public DateTimeOffset created;
            public List<regDefValue> keyValues;
        }

        public class regDefValue
        {
            public RegisterDefinition def;
            public String value;
        }

        private readonly DataTable _dataTable = new DataTable();
        private GenesisMeter _currentGenesis;
        private MeterBatch _meterBatch = new MeterBatch();
        private Color _defaultButtonColor;
        private regStore _regsToStore;
        private String _currentPcbId = "";

        private Boolean IsBusy
        {
            get;
            set;
        }

        public FrmRegisterStore()
        {
            InitializeComponent();

            //_dataTable = new DataTable();
            _dataTable.Columns.Add("Name", typeof(String));
            _dataTable.Columns.Add("Type", typeof(String));

            _dataTable.Columns.Add("isChecked", typeof(Boolean));
            _dataTable.Columns.Add("RawValue", typeof(String));
            _dataTable.Columns.Add("RawValueFile", typeof(String));
            _dataTable.Columns.Add("Value", typeof(String));

            _dataTable.Columns.Add("Min", typeof(String));
            _dataTable.Columns.Add("Max", typeof(String));
            _dataTable.Columns.Add("Description", typeof(String));

            _dataTable.Columns.Add("Version", typeof(String));
            _dataTable.Columns.Add("IsAvailable", typeof(String));

            _dataTable.Columns.Add("Privilege", typeof(String));

            _dataTable.Columns.Add("btnHistoryText", typeof(String));

            loadPreSet();
        }

        private void SetBusy(Boolean val, String action = "")
        {
            IsBusy = val;
            if (IsBusy)
            {
                Invoke(new Action(() =>
                {
                    probarBusy.Value = 0;
                    pnlBussy.Visible = true;
                    timProgress.Enabled = true;
                    lblAction.Text = action;
                }));
            }
            else
            {
                ProgressTotal = null;
                ProgressCurrent = null;
                Invoke(new Action(() =>
                {
                    pnlBussy.Visible = false;
                    timProgress.Enabled = false;
                    lblAction.Text = action;
                    lblProgress.Text = "";
                }));
            }
        }

        private void SetProgress(String text, Int32 total = 0, Int32 current = 0)
        {
            ProgressTotal = total;
            ProgressCurrent = current;
            Invoke(new Action(() => { lblProgress.Text = $@"{text} ({current}/{total})"; }));
        }

        private Int32? ProgressTotal;
        private Int32? ProgressCurrent;

        private void TimeProgress_tick(Object sender, EventArgs e)
        {
            if (IsBusy)
            {
                if (ProgressTotal.HasValue && ProgressCurrent.HasValue && !ProgressTotal.Value.Equals(0) &&
                    !ProgressCurrent.Value.Equals(0))
                {
                    try
                    {
                        probarBusy.Value =
                            (Int32)Math.Round((ProgressCurrent.Value / (Double)ProgressTotal.Value) * 100,
                                0);
                    }
                    catch (Exception)
                    {
                        //
                    }
                }
                else
                {
                    var current = probarBusy.Value;
                    if (current + 1 > 100)
                    {
                        current = 0;
                    }

                    probarBusy.Value = current + 1;
                }
            }
        }

        private void btnConnect_Click(Object sender, EventArgs e)
        {
            Connect();
        }

        private void btnRead_Click(Object sender, EventArgs e)
        {
            SetBusy(true, "Read Registers");

            var hex = "4F793AF100000002";
            var value = ulong.Parse(hex, NumberStyles.HexNumber);

            Console.WriteLine(value);


            Task.Factory.StartNew(() => { ReadRegisters(); }).ContinueWith(delegate
            {
                SetBusy(false);
            });
        }


        private void btnStore_Click(Object sender, EventArgs e)
        {
            SetBusy(true, "Store to file");
            Task.Factory.StartNew(() => { StoreFile(); }).ContinueWith(delegate
            {
                SetBusy(false);
            });
        }

        private void btnFileToMeter_Click(Object sender, EventArgs e)
        {
            var openFileDialog = new OpenFileDialog();
            openFileDialog.Filter = @"all JSON files (*.JSON)|*.JSON";
            openFileDialog.Multiselect = false;

            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                SetBusy(true, "writing to meter");

                var filename = openFileDialog.FileName;

                Task.Factory.StartNew(() => { LoadFile(filename); }).ContinueWith(delegate
                {
                    SetBusy(false);
                });
            }
        }


        private void registerGridView_CellEndEdit(Object sender, DataGridViewCellEventArgs e)
        {
            if (registerGridView.Columns[e.ColumnIndex].Name == "RawValue")
            {
                SetBusy(true, "writing register to meter");

                Task.Factory.StartNew(() => { WriteRegister(e); }).ContinueWith(delegate
                {
                    SetBusy(false);
                });

            }
        }

        private void WriteRegister(DataGridViewCellEventArgs e)
        {
            var inputValue = registerGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].Value.ToString();

            var arr = inputValue.Split('-');
            var array = new Byte[arr.Length];
            for (var i = arr.Length - 1; i >= 0; i--)
            {
                array[i] = Convert.ToByte(arr[i], 16);
            }

            var reg = (String)registerGridView.Rows[e.RowIndex].Cells[0].Value;
            var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
            var regDef = meterRegisters.GetRegisterDefinitionByName(reg);

            if (regDef.DataType != typeof(String) && regDef.DataType != typeof(ByteArray))
                array = array.Reverse().ToArray();
            _currentGenesis.WriteRegister(reg, array, checkRegister: true);
        }

        private void frmRegisterStore_Load(Object sender, EventArgs e)
        {
            _meterBatch = new MeterBatch();

            var configFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), nameof(Xylem.Common.Hardware.WaterMeter.Genesis), ProgramConfig.SerialConfigFileName);

            if (!File.Exists(configFile))
            {
                throw new ApplicationException($"Configuration file {configFile} not found ");
            }
            var tr = new StreamReader(configFile);
            var meterConfigList = JsonConvert.DeserializeObject<SlotConfig[]>(tr.ReadToEnd());
            cbComSlot.Items.Clear();
            var listSlots = new List<Int32>();
            if (listSlots == null) throw new ArgumentNullException(nameof(listSlots));
            foreach (var item in meterConfigList)
            {
                cbComSlot.Items.Add(item.Slot);
                listSlots.Add(item.Slot);
            }
            if (cbComSlot.Items.Count >= 1)
            {
                cbComSlot.SelectedItem = cbComSlot.Items[0];
            }

            var version = Assembly.GetExecutingAssembly().GetName().Version;
            lblGtbVersion.Text = $@"GTB Version: {version.Major}.{version.Minor}.{version.Build}";
            DisableAllButtons();

            btnConnect.Enabled = true;
            _defaultButtonColor = btnConnect.BackColor;
        }

        private void frmRegisterStore_FormClosing(Object sender, FormClosingEventArgs e)
        {
            _meterBatch.Dispose();
        }

        private void DisableAllButtons()
        {
            Invoke(new Action(() =>
            {
                btnConnect.Enabled = false;
                btnReadRegister.Enabled = false;

                btnRadioPressure.Enabled = false;
                btnSetDefaultPulse.Enabled = false;
                btnBatLife.Enabled = false;
                btnBatteryIdle.Enabled = false;
                btnCalibrationRestore.Enabled = false;
                btnStoreAll.Enabled = false;

                btnFileToRegister.Enabled = false;
                btnRegisterToFile.Enabled = false;

                btnReadFwVersions.Enabled = false;

                btnReadRegister.BackColor = _defaultButtonColor;

                btnRadioPressure.BackColor = _defaultButtonColor;
                btnSetDefaultPulse.BackColor = _defaultButtonColor;
                btnBatLife.BackColor = _defaultButtonColor;
                btnBatteryIdle.BackColor = _defaultButtonColor;
                btnCalibrationRestore.BackColor = _defaultButtonColor;
                btnStoreAll.BackColor = _defaultButtonColor;

                btnFileToRegister.BackColor = _defaultButtonColor;
                btnRegisterToFile.BackColor = _defaultButtonColor;

                btnReadFwVersions.BackColor = _defaultButtonColor;

            }));
        }

        private void EnableAllButtons()
        {
            Invoke(new Action(() =>
            {
                btnConnect.Enabled = true;
                btnReadRegister.Enabled = true;

                btnRadioPressure.Enabled = true;
                btnSetDefaultPulse.Enabled = true;
                btnBatLife.Enabled = true;
                btnBatteryIdle.Enabled = true;
                btnCalibrationRestore.Enabled = true;
                btnStoreAll.Enabled = true;

                btnFileToRegister.Enabled = true;
                btnRegisterToFile.Enabled = true;

                btnReadFwVersions.Enabled = true;
            }));
        }

        private void Connect()
        {
            try
            {
                if (string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
                    !int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNo))
                {
                    return;
                }

                SetBusy(true, "Connect");
                //disable all buttons
                DisableAllButtons();
                _currentGenesis?.DisposeMeter();
                //dispose old meter
                _meterBatch.RemoveAllMeters();
                _currentGenesis = null;

                //assign new meter and assign meter to FW update file if this exists
                _currentGenesis = new GenesisMeter();
                _currentGenesis.UseOfflinePasswords = cbxUseOfflinePwds.Checked;
                _currentGenesis.SetupFromConfigFile(slotNo);
                _meterBatch.AddMeter(_currentGenesis);

                Task.Factory.StartNew(() =>
                {
                    _meterBatch.MetersLogin();

                    if (!_currentGenesis.IsLoggedOn && String.IsNullOrEmpty(_currentGenesis.PcbId))
                    {
                        SetBusy(false);
                        MessageBox.Show(@"ERROR: Cannot read out PcbId! Access to Cordonel denied!");
                        return;
                    }

                    Invoke(new Action(() =>
                    {
                        if (_currentGenesis.IsLoggedOn)
                        {
                            lblState.ForeColor = Color.Green;
                            lblState.Text = $@"Connected to PCB {_currentGenesis.PcbId}";
                            lblConfigVersion.Text = @"Configuration Version: " +
                                                    _currentGenesis.InterfaceInfo.InterfaceVersion;
                            lblConfigVersion.ForeColor =
                                _currentGenesis.InterfaceSupportsFwVersion ? Color.Green : Color.Red;
                            if (!_currentGenesis.InterfaceSupportsFwVersion)
                            {
                                var text = "CONFIGURATION OUTDATED!\n\n" +
                                           "The loaded \"configuration.json\" " +
                                           $"version: {_currentGenesis.InterfaceInfo.InterfaceVersion}\n" +
                                           $"does NOT support the Cordonel FW version: {_currentGenesis.FwVersion}!";
                                MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }

                            _dataTable.Rows.Clear();

                            foreach (var item in _currentGenesis.GetRegistersDic())
                            {
                                var row = _dataTable.NewRow();
                                row["Name"] = item.Key.GetIdent();
                                row["Type"] = item.Key.DataType.Name;
                                row["isChecked"] = false;
                                row["Value"] = "";
                                row["RawValue"] = item.Value;
                                row["RawValueFile"] = item.Value;

                                row["Min"] = item.Key.Minimum;
                                row["Max"] = item.Key.Maximum;
                                row["Description"] = item.Key.RegisterDetail.Description;
                                var From = item.Key.RegisterDetail.Version.First.HasValue
                                    ? item.Key.RegisterDetail.Version.First.Value.ToString()
                                    : "-";

                                var To = item.Key.RegisterDetail.Version.Last.HasValue
                                    ? item.Key.RegisterDetail.Version.Last.Value.ToString()
                                    : "-";

                                row["Version"] = $"from {From} to {To}";
                                row["IsAvailable"] = item.Key.IsAvailable;
                                row["Privilege"] = item.Key.RegisterDetail.Privilege.Lvl8.ToString();
                                row["btnHistoryText"] = "View History";

                                _dataTable.Rows.Add(row);
                            }

                            registerGridView.DataSource = _dataTable.DefaultView;
                            var column = registerGridView?.Columns["isChecked"];
                            if (column != null)
                            {
                                column.SortMode = DataGridViewColumnSortMode.Automatic;
                                registerGridView.Sort(column, ListSortDirection.Descending);
                                var viewColumn = registerGridView.Columns["RawValueFile"];
                                if (viewColumn != null) viewColumn.Visible = false;

                            }

                            column = registerGridView?.Columns["Name"];
                            if (column != null)
                            {
                                registerGridView.Sort(column, ListSortDirection.Ascending);
                            }

                            var btnHistory = new DataGridViewButtonColumn();
                            btnHistory.Name = "btnHistory";

                            btnHistory.DataPropertyName = "btnHistoryText";
                            registerGridView?.Columns.AddRange(btnHistory);

                        }
                        else
                        {
                            btnConnect.Enabled = false;
                            lblState.ForeColor = Color.Red;
                            lblState.Text = $@"Not Connected to PcbId:{_currentGenesis.PcbId}";
                            registerGridView.Visible = false;
                        }
                    }));
                }).ContinueWith(delegate
                {
                    SetBusy(false);
                    EnableAllButtons();
                });
            }
            catch (Exception ex)
            {
                SetBusy(false);
                MessageBox.Show(ex.Message, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
                // Dispose meter
                _meterBatch.RemoveAllMeters();
                // If meter is not already assigned to batch as the config reader may fail
                _currentGenesis?.DisposeMeter();

                btnConnect.Enabled = true;
            }
        }

        private async void __Connect()
        {
            try
            {
                if (cbComSlot.SelectedItem == null ||
                    string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
                    !int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNo))
                {
                    return;
                }

                SetBusy(true, "Connect");
                DisableAllButtons();
                _dataTable.Rows.Clear();

                var result = await interfaceToLaatzen.ConnectOneSlotAsync(slotNo);

                if (result.Success)
                {
                    lblState.ForeColor = Color.Green;
                    lblState.Text = $@"Connected to PCB {result.PcbId}";
                    lblConfigVersion.Text = @"Configuration Version: " + result.InterfaceVersion;
                    lblConfigVersion.ForeColor = result.InterfaceSupportsFwVersion ? Color.Green : Color.Red;

                    if (!result.InterfaceSupportsFwVersion)
                    {
                        var text = "CONFIGURATION OUTDATED!\n\n" +
                                   "The loaded \"configuration.json\" " +
                                   $"version: {result.InterfaceVersion}\n" +
                                   $"does NOT support the Cordonel FW version: {result.FwVersion}!";

                        MessageBox.Show(text, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }

                    foreach (var item in result.Registers)
                    {
                        var row = _dataTable.NewRow();
                        row["Name"] = item.Name;
                        row["Type"] = item.Type;
                        row["isChecked"] = false;
                        row["Value"] = "";
                        row["RawValue"] = item.RawValue;
                        row["RawValueFile"] = item.RawValue;
                        row["Min"] = item.Min;
                        row["Max"] = item.Max;
                        row["Description"] = item.Description;
                        row["Version"] = item.Version;
                        row["IsAvailable"] = item.IsAvailable;
                        row["Privilege"] = item.Privilege;
                        row["btnHistoryText"] = "View History";

                        _dataTable.Rows.Add(row);
                    }

                    registerGridView.DataSource = _dataTable.DefaultView;

                    var column = registerGridView?.Columns["isChecked"];
                    if (column != null)
                    {
                        column.SortMode = DataGridViewColumnSortMode.Automatic;
                        registerGridView.Sort(column, ListSortDirection.Descending);

                        var viewColumn = registerGridView.Columns["RawValueFile"];
                        if (viewColumn != null)
                            viewColumn.Visible = false;
                    }

                    column = registerGridView?.Columns["Name"];
                    if (column != null)
                    {
                        registerGridView.Sort(column, ListSortDirection.Ascending);
                    }

                    if (registerGridView.Columns["btnHistory"] == null)
                    {
                        var btnHistory = new DataGridViewButtonColumn
                        {
                            Name = "btnHistory",
                            DataPropertyName = "btnHistoryText"
                        };

                        registerGridView.Columns.Add(btnHistory);
                    }

                    registerGridView.Visible = true;
                    btnConnect.Enabled = true;
                }
                else
                {
                    btnConnect.Enabled = false;
                    lblState.ForeColor = Color.Red;
                    lblState.Text = $@"Not Connected to PcbId:{result.PcbId}";
                    registerGridView.Visible = false;

                    MessageBox.Show(result.Message ?? "Connect failed.", @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, @"FAILED", MessageBoxButtons.OK, MessageBoxIcon.Error);
                btnConnect.Enabled = true;
            }
            finally
            {
                SetBusy(false);
                EnableAllButtons();
            }
        }

        private void GetPcbId(Int32 slotNR)
        {
            try
            {
                _meterBatch.RemoveAllMeters();
                _currentGenesis = new GenesisMeter();
                try
                {
                    _currentGenesis.SetupFromConfigFile(slotNR);
                    _meterBatch.AddMeter(_currentGenesis);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex, $"Slot #{slotNR} failed: {ex.Message}");
                }

                _currentPcbId = _currentGenesis.GetPcbId();

            }
            catch (Exception ex)
            {
                Logger.Error(ex, ex.Message);
            }

            _currentGenesis.Dispose();
            _currentGenesis = null;
        }

        private void SelectPreset(String content)
        {
            foreach (var rowItem in _dataTable.Rows)
            {
                if (rowItem is DataRow)
                {
                    ((DataRow)rowItem)["isChecked"] = false;
                }
            }


            switch (content)
            {
                case "All":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            ((DataRow)rowItem)["isChecked"] = true;
                        }
                    }

                    break;
                case "Ampl. Test":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            if (preSetAmplTest.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
                            {
                                ((DataRow)rowItem)["isChecked"] = true;
                            }
                            else
                            {
                                ((DataRow)rowItem)["isChecked"] = false;
                            }

                        }
                    }

                    break;
                case "Temp. Calibration":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            if (preSetTempCal.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
                            {
                                ((DataRow)rowItem)["isChecked"] = true;
                            }
                            else
                            {
                                ((DataRow)rowItem)["isChecked"] = false;
                            }

                        }
                    }

                    break;
                case "Zero Flow":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            if (preSetZeroFlow.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
                            {
                                ((DataRow)rowItem)["isChecked"] = true;
                            }
                            else
                            {
                                ((DataRow)rowItem)["isChecked"] = false;
                            }

                        }
                    }

                    break;
                case "Flow Calibration":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            if (preSetFlowCalibration.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
                            {
                                ((DataRow)rowItem)["isChecked"] = true;
                            }
                            else
                            {
                                ((DataRow)rowItem)["isChecked"] = false;
                            }
                        }
                    }

                    break;
                case "All Meteorological":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            if (preSetAllMeteorological.Any(p => p.Equals(((DataRow)rowItem)["Name"].ToString())))
                            {
                                ((DataRow)rowItem)["isChecked"] = true;
                            }
                            else
                            {
                                ((DataRow)rowItem)["isChecked"] = false;
                            }
                        }
                    }

                    break;
                case "Own":
                case "None":
                    foreach (var rowItem in _dataTable.Rows)
                    {
                        if (rowItem is DataRow)
                        {
                            ((DataRow)rowItem)["isChecked"] = false;
                        }
                    }

                    break;
            }



        }
        public class RegisterRestoreData
        {
            public Int32 PcbID { get; set; }
            public DateTime BuildTime { get; set; }
            public Dictionary<String, Byte[]> RegisterList { get; set; }

        }

        private RegisterRestoreData ReadRegisters()
        {

            if (_currentGenesis != null)
            {
                _regsToStore = new regStore
                {
                    PcbId = _currentGenesis.PcbId,
                    created = DateTimeOffset.Now,
                    keyValues = new List<regDefValue>()
                };

                var ret = new RegisterRestoreData
                {
                    PcbID = int.Parse(_currentGenesis.PcbId),
                    BuildTime = DateTime.Now,
                    RegisterList = new Dictionary<String, Byte[]>()
                };

                var total = 0;
                foreach (var rowItem in _dataTable.Rows)
                {
                    if (rowItem is DataRow)
                    {
                        if ((Boolean)((DataRow)rowItem)["isChecked"])
                        {
                            total += 1;
                        }
                    }
                }

                var done = 0;
                foreach (var rowItem in _dataTable.Rows)
                {
                    if (rowItem is DataRow)
                    {
                        if ((Boolean)((DataRow)rowItem)["isChecked"])
                        {

                            var reg = ((DataRow)rowItem)["Name"].ToString();

                            var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
                            var regDef = meterRegisters.GetRegisterDefinitionByName(reg);
                            SetProgress($"Read Register {regDef.RegisterName}", total, done + 1);
                            if (regDef.RegisterDetail != null && (
                                    regDef.RegisterDetail.Privilege.Lvl8 == Access.RO ||
                                    regDef.RegisterDetail.Privilege.Lvl8 == Access.RW))
                            {
                                try
                                {
                                    var rawRegister = _currentGenesis.ReadRegister(reg);
                                    ret.RegisterList[reg] = rawRegister;

                                    //var temp = RegisterConverter.GetRegisterContent(regDef, rawRegister);
                                    ((DataRow)rowItem)["RawValue"] = RegisterConverter.GetRegisterRawText(regDef, rawRegister);
                                    _regsToStore.keyValues.Add(new regDefValue
                                    {
                                        def = regDef,
                                        value = BitConverter.ToString(rawRegister)
                                    });

                                    try
                                    {
                                        var result = RegisterConverter.ConvertToText(rawRegister, regDef.DataType);
                                        ((DataRow)rowItem)["Value"] = result;
                                    }
                                    catch (Exception)
                                    {
                                        ((DataRow)rowItem)["Value"] = "not converted";
                                    }
                                }
                                catch (Exception)
                                {
                                    ((DataRow)rowItem)["Value"] = "error";
                                }
                            }
                            else
                            {
                                ((DataRow)rowItem)["RawValue"] = "No Access";
                                ((DataRow)rowItem)["Value"] = "";
                            }

                            done += 1;
                        }
                    }
                }

                return ret;
            }

            return null;
        }

        private void CompareFile(String filename)
        {

            var styleDiff = new DataGridViewCellStyle
            {
                BackColor = Color.Red,
                ForeColor = Color.Black
            };

            var styleEqual = new DataGridViewCellStyle
            {
                BackColor = Color.Green,
                ForeColor = Color.Black
            };

            SetProgress($"Read FileConfig {filename}");
            var text = File.ReadAllText(filename);
            var loadedRegStore = JsonConvert.DeserializeObject<regStore>(text);

            var done = 1;

            foreach (var rowItem in _dataTable.Rows)
            {
                if (rowItem is DataRow)
                {

                    SetProgress("Read file", loadedRegStore.keyValues.Count, done);

                    var reg = ((DataRow)rowItem)["Name"].ToString();
                    var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
                    var regDef = meterRegisters.GetRegisterDefinitionByName(reg);

                    var keyValue =
                        loadedRegStore.keyValues.FirstOrDefault(f => f.def.RegisterName.Equals(regDef.RegisterName));
                    if (keyValue != null)
                    {
                        ((DataRow)rowItem)["RawValueFile"] = keyValue.value;

                        if (regDef.RegisterDetail.Privilege.Lvl8 == Access.RO ||
                            regDef.RegisterDetail.Privilege.Lvl8 == Access.RW)
                        {
                            var rawRegister = _currentGenesis.ReadRegister(reg);

                            //var temp = RegisterConverter.GetRegisterContent(regDef, rawRegister);
                            ((DataRow)rowItem)["RawValue"] = RegisterConverter.GetRegisterRawText(regDef, rawRegister);
                            _regsToStore.keyValues.Add(new regDefValue
                            {
                                def = regDef,
                                value = BitConverter.ToString(rawRegister)
                            });

                            try
                            {
                                var result = RegisterConverter.ConvertToText(rawRegister, regDef.DataType);
                                ((DataRow)rowItem)["Value"] = result;
                            }
                            catch (Exception)
                            {
                                ((DataRow)rowItem)["Value"] = "not converted";
                            }


                            DataGridViewCell meterCell = null;
                            DataGridViewCell fileCell = null;
                            foreach (DataGridViewRow row in registerGridView.Rows)
                            {
                                if (row.Cells["Name"].Value.Equals(regDef.RegisterName))
                                {
                                    meterCell = row.Cells["RawValue"];
                                    fileCell = row.Cells["RawValueFile"];
                                    break;
                                }
                            }

                            if (meterCell != null && fileCell != null)
                            {
                                if (BitConverter.ToString(rawRegister).Equals(keyValue.value))
                                {

                                    meterCell.Style = styleEqual;
                                    fileCell.Style = styleEqual;
                                }
                                else
                                {
                                    meterCell.Style = styleDiff;
                                    fileCell.Style = styleDiff;
                                }
                            }
                        }
                        else
                        {
                            ((DataRow)rowItem)["RawValue"] = "No Access";
                            ((DataRow)rowItem)["Value"] = "";
                        }

                        done += 1;
                    }
                    else
                    {
                        ((DataRow)rowItem)["RawValueFile"] = "Not in FileConfig";
                    }
                }
            }
        }

        private void ShowFile(String filename)
        {
            SetProgress($"Read FileConfig {filename}");
            var text = File.ReadAllText(filename);
            var loadedRegStore = JsonConvert.DeserializeObject<regStore>(text);

            var done = 1;

            foreach (var rowItem in _dataTable.Rows)
            {
                if (rowItem is DataRow)
                {

                    SetProgress("Compare file", loadedRegStore.keyValues.Count, done);
                    var regDef = (RegisterDefinition)((DataRow)rowItem)["regDef"];
                    var keyValue =
                        loadedRegStore.keyValues.FirstOrDefault(f => f.def.RegisterName.Equals(regDef.RegisterName));
                    if (keyValue != null)
                    {
                        ((DataRow)rowItem)["RawValueFile"] = keyValue.value;

                    }
                    else
                    {
                        ((DataRow)rowItem)["RawValueFile"] = "Not in FileConfig";
                    }

                    done += 1;
                }
            }
        }

        private void LoadFile(String filename)
        {
            //SetProgreess($"Read FileConfig {filename}");
            //var text = FileConfig.ReadAllText(filename);
            //var loadedRegStore = Newtonsoft.Json.JsonConvert.DeserializeObject<regStore>(text);
            //if (loadedRegStore.PcbId != _currentPcbId)
            //{
            //    MessageBox.Show($"Please connect to PCB {loadedRegStore.PcbId}");
            //    return;
            //}

            //var done = 1;
            //foreach (var keyValueToWrite in loadedRegStore.keyValues)
            //{
            //    SetProgreess($"Write Register {keyValueToWrite.def.Name}", loadedRegStore.keyValues.Count, done);
            //    var valueToWrite = keyValueToWrite.value.Split('-').Select(b => Convert.ToByte(b, 16));
            //    valueToWrite.Reverse();
            //    _currentGenesis.WriteRegister(keyValueToWrite.def, valueToWrite.ToArray());

            //    done = done + 1;
            //}

            //read();
        }

        private void StoreFile()
        {
            //read();
            //var text = Newtonsoft.Json.JsonConvert.SerializeObject(regsToStore);
            //SaveFileDialog saveFileDialog = new SaveFileDialog();
            //saveFileDialog.FileName = $"storePcbId{regsToStore.PcbId}on{regsToStore.created.ToString("yyyyMMdd")}.json";

            //Invoke(new Action(() =>
            //{

            //    if (saveFileDialog.ShowDialog() == DialogResult.OK)
            //        FileConfig.WriteAllText(saveFileDialog.FileName, text);

            //}));

            //var done = 1;
            //foreach (var keyValueToWrite in regsToStore.keyValues)
            //{
            //    SetProgreess($"Write Register {keyValueToWrite.def.Name}", regsToStore.keyValues.Count, done);
            //    var valueToWrite = keyValueToWrite.value.Split('-').Select(b => Convert.ToByte(b, 16));
            //    valueToWrite.Reverse();
            //    _currentGenesis.WriteRegister(keyValueToWrite.def, valueToWrite.ToArray());

            //    done = done + 1;
            //}

        }

        private void StoreAsCsv()
        {
            ReadRegisters();

            var csv = new StringBuilder();
            var saveFileDialog = new SaveFileDialog();
            saveFileDialog.FileName = $"storePcbId{_regsToStore.PcbId}on{_regsToStore.created.ToString("yyyyMMdd")}.csv";

            csv.AppendLine("name;value");
            foreach (var values in _regsToStore.keyValues)
            {
                csv.AppendLine($"{values.def.RegisterName};{values.value}");
            }

            Invoke(new Action(() =>
            {

                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    File.WriteAllText(saveFileDialog.FileName, csv.ToString());
                }
            }));
        }

        private List<String> preSetAmplTest = new List<String>();
        private List<String> preSetTempCal = new List<String>();
        private List<String> preSetZeroFlow = new List<String>();
        private List<String> preSetFlowCalibration = new List<String>();
        private List<String> preSetAllMeteorological = new List<String>();
        private List<String> preSetDefault = new List<String>();
        private void loadPreSet()
        {
            #region defaults
            preSetDefault.Add(Register.Genesisflow.SampleRate);
            preSetDefault.Add(Register.Genesisflow.LedMode);
            preSetDefault.Add(Register.Genesisflow.MeterSize);
            #endregion

            #region preSetAmplTest

            preSetAmplTest.Add(Register.Genesisflow.FirstHitUpdatePeriod);
            preSetAmplTest.Add(Register.Genesisflow.FirstHitShift);
            preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent1);
            preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent2);
            preSetAmplTest.Add(Register.Genesisflow.FirstHitPercent3);

            #endregion

            #region preSetTempCal

            preSetTempCal.Add(Register.Genesisflow.ToFTempCalibrate);
            preSetTempCal.Add(Register.Genesisflow.ToFTempOffset1);
            preSetTempCal.Add(Register.Genesisflow.ToFTempOffset2);
            preSetTempCal.Add(Register.Genesisflow.ToFTempOffset3);

            #endregion

            #region preSetZeroFlow

            preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset1);
            preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset2);
            preSetZeroFlow.Add(Register.Genesisflow.ZeroOffset3);

            #endregion

            #region preSetAllMeteorological

            preSetFlowCalibration.Add(Register.Genesisflow.CalFactor1);
            preSetFlowCalibration.Add(Register.Genesisflow.CalFactor2);
            preSetFlowCalibration.Add(Register.Genesisflow.CalFactor3);

            #endregion

            #region preset All metro

            preSetAllMeteorological.AddRange(preSetAmplTest);
            preSetAllMeteorological.AddRange(preSetTempCal);
            preSetAllMeteorological.AddRange(preSetZeroFlow);
            preSetAllMeteorological.AddRange(preSetFlowCalibration);

            #endregion

            #region addDefaults

            preSetAllMeteorological.AddRange(preSetDefault);
            preSetZeroFlow.AddRange(preSetDefault);
            preSetFlowCalibration.AddRange(preSetDefault);
            preSetTempCal.AddRange(preSetDefault);
            preSetAmplTest.AddRange(preSetDefault);

            #endregion
        }

        private void btnGetPCbID_Click(Object sender, EventArgs e)
        {
            Logger.Trace("UI-CLICK: FrmRegisterStore: btnGetPCbID_Click() use APILaatzen");

            if (cbComSlot.SelectedItem != null) // && cbComSlot.SelectedValue is ListBoxItem)
            {
                _currentPcbId = "";
                if (!string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) &&
                    int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNR))
                {

                    SetBusy(true, "GetPcbId");

                    // as new meter object will be generated the data grid shows outdated data
                    _dataTable.Rows.Clear();
                    DisableAllButtons();

                    Task.Factory.StartNew(() => { GetPcbId(slotNR); }).ContinueWith(delegate
                    {
                        Invoke(new Action(() =>
                        {
                            SetBusy(false);
                            btnConnect.Enabled = true;
                            MessageBox.Show(_currentPcbId);
                        }));
                    });

                }
            }
        }

        private async void __btnGetPCbID_Click(object sender, EventArgs e)
        {
            Logger.Trace("UI-CLICK: FrmRegisterStore: btnGetPCbID_Click() use API2");

            if (cbComSlot.SelectedItem == null)
                return;

            if (!int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNr))
                return;

            try
            {
                _currentPcbId = "";

                SetBusy(true, "GetPcbId");

                _dataTable.Rows.Clear();
                DisableAllButtons();

                GciPublicModels.GciGetPcbIdResult result =
                    await interfaceToLaatzen.GetPcbIdAsync(slotNr);

                if (!result.Success)
                    throw new Exception(result.Message);

                _currentPcbId = result.PcbId;

                btnConnect.Enabled = true;

                Logger.Info("COM: Request detection SUCCESS for slot " + slotNr);

                MessageBox.Show(_currentPcbId);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);

                Logger.Error("COM: Request detection FAILED for slot " + slotNr);
            }
            finally
            {
                SetBusy(false);
            }
        }

        private void btnReadFwVersions_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                var sb = new StringBuilder();
                sb.AppendLine($"PCBID: {_currentGenesis.PcbId}");
                sb.AppendLine($"Date: {DateTimeOffset.UtcNow}");
                sb.AppendLine($"System Core Revision: {_currentGenesis.StrCoreRevision}");
                foreach (var fm in _currentGenesis.MeterAppListVersion.OrderBy(o => o.AppId))
                {
                    var versionString = fm.IsInstalled
                        ? $"V: {fm.StrVersion} - CRC: 0x{fm.Crc:X4}" : "Not installed";
                    if (fm.Status == MeterAppState.Unknown)
                        versionString = "Communication error";

                    sb.AppendLine($"AppId: 0x{fm.AppId:X2} - {versionString} - AppName: {fm.AppName}");
                }

                MessageBox.Show(sb.ToString());
            }
        }

        private void btnProgram_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                var fa = new List<Byte>();
                fa.AddRange((new Byte[] { 0x0E, 0x9F, 0xAC, 0xC6 }));
                fa.AddRange((new Byte[] { 0xA0, 0xE1, 0xEF, 0x1C }));
                fa.AddRange((new Byte[] { 0x3B, 0x27, 0xA4, 0x9B }));
                fa.AddRange((new Byte[] { 0xAC, 0x21, 0x65, 0x35 }));
                _currentGenesis.ReLogin();
                _currentGenesis.WriteRegister("SENSUSRADIO_EncryptionKey", fa.ToArray());
                //var before = _currentGenesis.ReadRegister("SYSTEM_CalendarSeconds");

                //var tsa = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));
                //_currentGenesis.WriteRegister("SYSTEM_CalendarSeconds", Convert.ToInt32(tsa.TotalSeconds));

                //var after = _currentGenesis.ReadRegister("SYSTEM_CalendarSeconds");




                //#region fixparameter

                //register	final programming

                //var overAllResult = new List<Tuple<String, Boolean>>();
                ////611.219.280 
                ////
                //var ts = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));




                ////Alarms
                //////_currentGenesis.WriteRegister("SENSUSRADIO_MainAlarmMask?
                //////_currentGenesis.WriteRegister("SENSUSRADIO_ExtendedAlarmMask	?
                ////CUSTOMER_AlarmBroadcastMask?
                ////CUSTOMER_AlarmEnableMask	?
                ////CUSTOMER_AlarmVisualAutoClearMask?
                ////CUSTOMER_AlarmVisualMask	?
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));

                //overAllResult.Add(_currentGenesis_WriteRegister("SYSTEM_CalendarSeconds",
                //    Convert.ToInt32(ts.TotalSeconds), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ExcessFlowTimeThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x05 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ExcessFlowVolumeThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x61, 0xA8 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_LeakFlowThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x01, 0x77 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_LeakTimeThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x4E, 0xC0 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_Locale",
                //    (new Byte[] { 0x00, 0x00, 0x01, 0x60 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureHighDelay",
                //    (new Byte[] { 0x00, 0x00, 0x02, 0x58 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureHighThreshold",
                //    (new Byte[] { 0x00, 0x0B, 0x71, 0xB0 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureLowDelay",
                //    (new Byte[] { 0x00, 0x00, 0x02, 0x58 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_PressureLowThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x75, 0x30 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_ReverseFlowTimeThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x78 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureHighDelay",
                //    (new Byte[] { 0x00, 0x00, 0x01, 0x2C }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureHighThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x01, 0xF4 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureLowDelay",
                //    (new Byte[] { 0x00, 0x00, 0x01, 0x2C }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("CUSTOMER_TemperatureLowThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x14 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ArrowThreshold",
                //    (new Byte[] { 0x00, 0x1E, 0x84, 0x80 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_DisplayPow10",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0xFD }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ForwardArrow",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_HardErrorLimit",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LedMode",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                ////overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", (new Byte[] { 0x00, 0x00, 0x00, 0x3C }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", 60 << 16, true, true));

                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_LowFlowThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0xC8 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_MeterSize",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_PipeFillingDelay",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x1E }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_ResetAccumulators",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, false));
                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SampleRate",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));

                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_UpdateThreshold",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("IRDA_AdapterPresenceLimit",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x60 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("IRDA_PulseReportRate",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_FlowPoint",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_FlowUnits",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureOffset",
                //    (new Byte[] { 0x00, 0x00, 0x03, 0xF5 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressurePresent",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureRate",
                //    (new Byte[] { 0x00, 0x0D, 0xBB, 0xA0 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PressureUnits",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseLength",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x07 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseMode",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_PulseWeight",
                //    (new Byte[] { 0x00, 0x00, 0x27, 0x10 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_AverageFlowPeriod",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x05 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_DataLogContents",
                //    (new Byte[] { 0x08, 0x00, 0x24, 0x03 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_DataLogPeriod",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x3C }).Reverse().ToArray(), true, false));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_FixedDateDayOfMonth",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_FixedDateReadingContents",
                //    (new Byte[] { 0x08, 0x00, 0x24, 0x03 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_PeriodicLogLifeTimeCounter",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x0 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("PERIODICLOG_ResetCounter",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x0 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("POWERMON_BatterySelection",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, false));
                //overAllResult.Add(_currentGenesis_WriteRegister("POWERMON_WarnFromClamp",
                //    (new Byte[] { 0x00, 0x01, 0x51, 0x80 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_WakeupInterval",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x03 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_MbusState",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x07 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_UtcTimeOffset",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));

                //// just read later //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_FrequencyIndicator}).Reverse(), true, true);

                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_HistoricalAlarmsDays",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x1D }).Reverse().ToArray(), true, true));


                ////Original
                ////0x11, 0x12, 0x13, 0x14, 0x21, 0x22, 0x23, 0x24, 0x31, 0x32, 0x33, 0x34, 0x41, 0x42, 0x43, 0x44
                ////Write to register
                ////0x14, 0x13, 0x12, 0x11, 0x24, 0x23, 0x22, 0x21, 0x34, 0x33, 0x32, 0x31, 0x44, 0x43, 0x42, 0x41


                ////good one
                ////E6-C8-88-00-DE-B8-68-C0-D6-A8-48-80-CE-98-28-40
                ////0E-05-04-04-00-14-30-68-D0-14-0E-80-40-63-93-73-22

                ////&bad one
                ////0E-05-04-05-00-00-88-C8-E6-C0-68-B8-DE-80-48-A8-D6-40-28-98-CE


                ////0E-05-04-04-00-22-73-93-63-40-80-0E-14-D0-68-30-14

                //var funkadresse = new List<Byte>();
                //funkadresse.AddRange((new Byte[] { 0xE6, 0xC8, 0x88, 0x00 }).ToArray());
                //funkadresse.AddRange((new Byte[] { 0xDE, 0xB8, 0x68, 0xC0 }).ToArray());
                //funkadresse.AddRange((new Byte[] { 0xD6, 0xA8, 0x48, 0x80 }).ToArray());
                //funkadresse.AddRange((new Byte[] { 0xCE, 0x98, 0x28, 0x40 }).ToArray());
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey", funkadresse.ToArray(),
                //    true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey",
                //    (new Byte[]
                //    {
                //        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
                //    }).ToArray(), true, true));
                ////overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[] { 0x14, 0x30, 0x68, 0xD0, 0x14, 0x0E, 0x80, 0x40, 0x63, 0x93, 0x73, 0x22 }).ToArray(), true, true));
                ////overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[]
                ////{
                ////    0xD0,0x68 , 0x30 ,0x14,
                ////    0x40,0x80, 0x0E ,0x14,
                ////    0x22, 0x73, 0x93,0x63
                ////}).ToArray(), true, true));
                //////E6C88800DEB868C0D6A84880CE982840

                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_CustomerText",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));

                //using (var dataacces =
                //    new SqlDataAccess(
                //        "Data Source=SLASQL01;;Initial Catalog=Auftrag;Persist Security Info=False;User ID=GenesisPasswordService;Password=PcbID;")
                //)
                //{

                //    var sb = new StringBuilder();
                //    sb.AppendLine(
                //        $" SELECT distinct  [MapPcbIdToSerialNumber_SerialNumber],Adresse,FunkschluesselIndex,SENSUSRADIO_PowerLevel, SENSUSRADIO_PowerLevelOption, SENSUSRADIO_ImpedanceCodeNew,SENSUSRADIO_ImpedanceCodeOption ");
                //    sb.AppendLine($" FROM [Auftrag].[dbo].[MapPcbIdToSerialNumber] pcb ");
                //    sb.AppendLine(
                //        $" inner join tmpRadioConfig radio on radio.pcbID = pcb.MapPcbIdToSerialNumber_PcbId");
                //    sb.AppendLine(
                //        $" inner join Genesis_Meter meter on meter.Seriennummer = pcb.MapPcbIdToSerialNumber_SerialNumber");
                //    sb.AppendLine($" where [MapPcbIdToSerialNumber_PcbId] = '{_currentGenesis.GetPcbId()}'");

                //    var MapData = dataacces.ExecuteQuery(sb.ToString());
                //    if (MapData.Rows.Count != 1)
                //    {
                //        MessageBox.Show("Faild to get order data");
                //        return;
                //    }

                //    var SENSUSRADIO_RadioAddress = Convert.ToUInt32((Int64)MapData.Rows[0]["Adresse"] - 10000000000);
                //    var SENSUSRADIO_PowerLevel = Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_PowerLevel"]);
                //    var SENSUSRADIO_PowerLevelOption =
                //        Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_PowerLevelOption"]);
                //    var SENSUSRADIO_ImpedanceCodeNew =
                //        Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_ImpedanceCodeNew"]);
                //    var SENSUSRADIO_ImpedanceCodeOption =
                //        Convert.ToUInt32(MapData.Rows[0]["SENSUSRADIO_ImpedanceCodeOption"]);


                //    overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_RadioAddress",
                //        SENSUSRADIO_RadioAddress, true, true));
                //    overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_PowerLevel", SENSUSRADIO_PowerLevel,
                //        true, true));
                //    overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_PowerLevelOption",
                //        SENSUSRADIO_PowerLevelOption, true, true));
                //    overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_ImpedanceCodeNew",
                //        SENSUSRADIO_ImpedanceCodeNew, true, true));
                //    overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_ImpedanceCodeOption",
                //        SENSUSRADIO_ImpedanceCodeOption, true, true));


                //}

                ////MapData.Rows[0]["Adresse"]


                //overAllResult.Add(_currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true));

                ////radio end state!
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_SystemState",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0xFF }).Reverse().ToArray(), true, false));

                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_SystemState",
                //    (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true));

                //var sbR = new StringBuilder();
                //if (overAllResult.Any(a => a.Item2 == false))
                //{

                //    foreach (var failedIndex in overAllResult)
                //    {
                //        if (!failedIndex.Item2)
                //        {
                //            sbR.AppendLine($"Register={failedIndex.Item1} failed");
                //        }

                //    }
                //}
                //else
                //{
                //    sbR.AppendLine($"done without errors");
                //}

                //_currentGenesis.Logout();
                //MessageBox.Show("Result:" + sbR.ToString());

                //#endregion

                ////radio
                ////storeconfig _all
                ////log out
                ////using (var dataacces = new SqlDataAccess(GlobalConfig.connectionString.Value))
                ////{

                //var resultDic = new Dictionary<string, object>();

                //    resultDic.Add("SENSUSRADIO_RadioAddress", ra);

                //    //10412000966

                //resultDic.Add("SENSUSRADIO_EncryptionKey", new Byte[] {0x40, 0x28, 0x98, 0xCE, 0x00});

                //}


                ////radio

                //    //[Adresse]



                //    var listToCheckProgramm = new Dictionary<string, byte[]>();

                //listToCheckProgramm.Add("", new byte[]{ 0x00, 0x00, 0x00, 0x00});

                //listToCheckProgramm.Add("", new byte[] { 0x00, 0x00, 0x00, 0x00 });

                //listToCheckProgramm.Add("", new byte[] { 0x00, 0x00, 0x00, 0x00 });








            }
        }

        public Tuple<String, Boolean> _currentGenesis_WriteRegister<T>(String reg, T value, Boolean waitForResult = true,
            Boolean checkRegister = false)
        {
            return new Tuple<String, Boolean>(reg,
                _currentGenesis.WriteRegister(reg, value, waitForResult, checkRegister));
        }

        private void btnJsonCheck_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                var allSucceed = true;
                var List = _currentGenesis.GetRegistersDic().Keys.ToList();
                foreach (var VARIABLE in List)
                {

                    if ((VARIABLE.RegisterDetail.Privilege.Lvl8 == Access.RO
                         || VARIABLE.RegisterDetail.Privilege.Lvl8 == Access.RW)
                    )
                    {
                        var a = _currentGenesis.ReadRegister(VARIABLE.GetIdent());
                        //String result = RegisterCheck.CheckRange(VARIABLE, a);
                        if (StatusReturn.Failed == RegisterCheck.CheckRange(VARIABLE, a, out var result))
                        {
                            MessageBox.Show(result);
                            allSucceed = false;
                        }
                    }
                }

                if (allSucceed)
                {
                    MessageBox.Show(@"Json Check Succeed!");
                }
                else
                {
                    MessageBox.Show(@"Json Check Failed!");
                }
            }
        }

        private void btnReadyForTestBench_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {

                _currentGenesis.ReLogin();

                //var rees1 = _currentGenesis.ReadRegister("SENSUSRADIO_EncryptionKey",32);
                //var rees2 = _currentGenesis.ReadRegister("SENSUSRADIO_Authentification", 32);
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_EncryptionKey", (new Byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true));
                //overAllResult.Add(_currentGenesis_WriteRegister("SENSUSRADIO_Authentification", (new Byte[] { 0x14, 0x30, 0x68, 0xD0, 0x14, 0x0E, 0x80, 0x40, 0x63, 0x93, 0x73, 0x22 }).Reverse().ToArray(), true, true));

                _currentGenesis_WriteRegister("GENESISFLOW_LowFlowMaxPeriod", 60 << 16, true, true);


                _currentGenesis.ResetAlarm(Alarm.EMPTY_PIPE | Alarm.REBOOT);
                //TODO set display unit 
                //TODO calculated overflow volume for display 
                _currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);

                _currentGenesis.WriteRegister<Byte>(Register.Genesisflow.SampleRate, 10, checkRegister: true);
                _currentGenesis.WriteRegister(Register.Genesisflow.LedMode, 6, checkRegister: true);
                _currentGenesis.WriteRegister("GENESISFLOW_TriggerActive", 1);

                _currentGenesis_WriteRegister("GENESISFLOW_DisplayPow10",
                    (new Byte[] { 0x00, 0x00, 0x00, 0xFA }).Reverse().ToArray(), true, true);


            }
        }

        private void button1_Click_2(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                _currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                    (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);

                _currentGenesis_WriteRegister("CUSTOMER_Locale",
                    (new Byte[] { 0x00, 0x00, 0x00, 0x24 }).Reverse().ToArray(), true, true);


                _currentGenesis_WriteRegister("METROLOGYASST_PulseWeight", (new Byte[] { 0x00, 0x00, 0x0E, 0xC9 }).Reverse().ToArray(), true, true);
                _currentGenesis_WriteRegister("METROLOGYASST_FlowPoint", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
                _currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);
                _currentGenesis_WriteRegister("METROLOGYASST_FlowUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x06 }).Reverse().ToArray(), true, true);
                _currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true);


                _currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                    (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);



            }
        }

        private void button2_Click_1(Object sender, EventArgs e)
        {
            _currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);


            _currentGenesis_WriteRegister("CUSTOMER_Locale",
                (new Byte[] { 0x00, 0x00, 0x00, 0xD0 }).Reverse().ToArray(), true, true);

            _currentGenesis_WriteRegister("METROLOGYASST_PulseWeight", (new Byte[] { 0x00, 0x00, 0x03, 0xE8 }).Reverse().ToArray(), true, true);
            _currentGenesis_WriteRegister("METROLOGYASST_FlowPoint", (new Byte[] { 0x00, 0x00, 0x00, 0x02 }).Reverse().ToArray(), true, true);
            _currentGenesis_WriteRegister("METROLOGYASST_TemperatureUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);
            _currentGenesis_WriteRegister("METROLOGYASST_FlowUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x04 }).Reverse().ToArray(), true, true);
            _currentGenesis_WriteRegister("GENESISFLOW_DisplayUnits", (new Byte[] { 0x00, 0x00, 0x00, 0x00 }).Reverse().ToArray(), true, true);

            _currentGenesis_WriteRegister("GENESISFLOW_SealDisplay",
                (new Byte[] { 0x00, 0x00, 0x00, 0x01 }).Reverse().ToArray(), true, true);
        }

        private void registerGridView_CellClick(Object sender, DataGridViewCellEventArgs e)
        {
            if (e.ColumnIndex > 0 && registerGridView.Columns[e.ColumnIndex] is DataGridViewButtonColumn)
            {
                if (_currentGenesis != null && _currentGenesis.IsLoggedOn)
                {
                    var regdef = (String)registerGridView.Rows[e.RowIndex].Cells[0].Value;
                    var keyvalueRegdef = _currentGenesis.GetRegistersDic().FirstOrDefault(f => f.Key.GetIdent() == regdef);
                    if (keyvalueRegdef.Key != null)
                    {
                        /*var frmDialog = new FrmRegisterHistory(_currentGenesis.PcbId, keyvalueRegdef.Key);
                        frmDialog.SetDesktopLocation(Cursor.Position.X, Cursor.Position.Y);
                        frmDialog.ShowDialog();*///...MF
                    }



                }
            }
        }

        private String _preSelectReminder = "None";

        private void lblState_Click(Object sender, EventArgs e)
        {
            if (_preSelectReminder.Contains("None"))
            {
                _preSelectReminder = "All";
                SelectPreset("All");
            }
            else
            {
                _preSelectReminder = "None";
                SelectPreset("None");
            }
        }

        private void btnSetDefaultPulse_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                btnSetDefaultPulse.BackColor = Color.Yellow;
                try
                {
                    if (_currentGenesis.IsLoggedOn)
                    {
                        _currentGenesis.WriteRegister("METROLOGYASST_PulseMode", 1);

                        _currentGenesis.WriteRegister("METROLOGYASST_PulseWeight", 32000);

                        _currentGenesis.WriteRegister("METROLOGYASST_PulseLength", 8);
                        _currentGenesis.WriteRegister("GENESISFLOW_SampleRate", 2);
                        _currentGenesis.WriteRegister("GENESISFLOW_LedMode", 0);

                        _currentGenesis.WriteRegister("GENESISFLOW_TriggerActive", 1);

                        btnSetDefaultPulse.BackColor = Color.Green;
                        _currentGenesis.Logout();
                        return;
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

                _currentGenesis.Logout();
                btnSetDefaultPulse.BackColor = Color.Red;
            }
        }

        private void btnBatteryIdle_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                btnBatteryIdle.BackColor = Color.Yellow;
                try
                {
                    var ts = DateTimeOffset.UtcNow - new DateTimeOffset(2000, 1, 1, 0, 0, 0, new TimeSpan(0));
                    if (_currentGenesis.IsLoggedOn)
                    {
                        _currentGenesis.WriteRegister("GENESISFLOW_SealDisplay", 0);
                        _currentGenesis.WriteRegister("POWERMON_WarnFromClamp", (UInt32)473040000);
                        _currentGenesis.WriteRegister("SYSTEM_CalendarSeconds", Convert.ToInt32(ts.TotalSeconds));
                        var r = _currentGenesis.ReadRegister(Register.Genesisflow.TriggerIdle);
                        if (r[1] == 18)
                        {
                            var newVal = r[0] + 0x01;
                            var n = new Byte[] { (Byte)newVal, r[1], 0x00, 0x00 };

                            _currentGenesis.WriteRegister(Register.Genesisflow.TriggerIdle, n);
                        }
                        else
                        {
                            _currentGenesis.SetLcdText(false, new Byte[] { 0x12, 0x35 });
                        }

                        btnBatteryIdle.BackColor = Color.Green;
                        _currentGenesis.Logout();
                        return;
                    }

                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

                btnBatteryIdle.BackColor = Color.Red;
                _currentGenesis.Logout();
            }
        }

        private void label1_Click(Object sender, EventArgs e)
        {

        }

        private void btnStoreAll_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                btnStoreAll.BackColor = Color.Yellow;
                try
                {
                    if (_currentGenesis.IsLoggedOn)
                    {
                        var resultAll = _currentGenesis.StoreAllConfigurations();
                        if (resultAll)
                        {
                            btnStoreAll.BackColor = Color.Green;
                            _currentGenesis.Logout();
                            return;
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

                _currentGenesis.Logout();
                btnStoreAll.BackColor = Color.Red;
            }
        }

        //private void btn0406_Click(object sender, EventArgs e)
        //{
        //    if (cbComSlot.SelectedItem != null) // && cbComSlot.SelectedValue is ListBoxItem)
        //    {
        //        Int32 slotNR = 0;
        //        if (!string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) &&
        //            int.TryParse(cbComSlot.SelectedItem.ToString(), out slotNR))
        //        {

        //            btn0406.BackColor = Color.Yellow;
        //            try
        //            {
        //                foreach (var me in _meterBatch.ListOfMeters)
        //                {
        //                    if (me is GenesisMeter)
        //                    {
        //                        if (((GenesisMeter)me).IsLoggedOn)
        //                        {
        //                            _currentGenesis = ((GenesisMeter)me);



        //                             _currentGenesis.WriteRegister("CUSTOMER_StoreConfiguration", 1);

        //                            var reboot = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("CUSTOMER_RebootCount"));
        //                            var PERIODICLOG_ResetCounter = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("PERIODICLOG_ResetCounter"));
        //                            var SENSUSRADIO_ResetCounter = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("SENSUSRADIO_ResetCounter"));

        //                            var rebootSeconds = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("SYSTEM_MonotonicSeconds"));
        //                            var Storeconfig = ByteArrayStyle.ByteStyler.ToString(_currentGenesis.ReadRegister("CUSTOMER_StoreConfiguration"));
        //                            _currentGenesis.WriteLog($"#+#+#{_currentGenesis.PcbId};{Storeconfig};{reboot};{rebootSeconds};{cbProd.Checked};{txtTest.Text};{PERIODICLOG_ResetCounter};{SENSUSRADIO_ResetCounter}");

        //                            btn0406.BackColor = Color.Green;
        //                            btn0406.Text = Storeconfig;
        //                            return;
        //                        }

        //                    }
        //                }

        //            }
        //            catch (Exception ex)
        //            {
        //                btn0406.BackColor = Color.Red;
        //                MessageBox.Show(ex.Message);
        //            }


        //        }
        //    }
        //}


        private void CheckAndDisplayRebootCount()
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                timer1.Enabled = false;
                btnRegisterToFile.BackColor = Color.Yellow;
                try
                {

                    if (_currentGenesis.IsLoggedOn)
                    {
                        var reboot = _currentGenesis.ReadRegister("CUSTOMER_RebootCount");
                        _currentGenesis.ReadRegister("POWERMON_BatteryQuantity");
                        _currentGenesis.SetLcdText(false, new Byte[] { 0xAC, reboot[0] });
                        btnRegisterToFile.BackColor = Color.Green;
                        timer1.Enabled = true;
                        _currentGenesis.Logout();
                        return;
                    }

                }
                catch (Exception)
                {
                    timer1.Enabled = true;
                    btnRegisterToFile.BackColor = Color.Red;
                    return;
                }

                _currentGenesis.Logout();
                timer1.Enabled = true;
                btnRegisterToFile.BackColor = Color.Gray;
            }
        }

        private void timer1_Tick(Object sender, EventArgs e)
        {
            CheckAndDisplayRebootCount();
        }


        private void btnBatLife_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                try
                {
                    if (_currentGenesis.IsLoggedOn)
                    {
                        var t = new JustageResults
                        {
                            pcbId = _currentGenesis.PcbId,
                            p1Target = 0,
                            p1Value = RegisterConverter.ByteArrayToValue<UInt16>(
                                _currentGenesis.ReadRegister(Register.Genesisflow.CalFactor1)),
                            p2Target = 0,
                            p2Value = RegisterConverter.ByteArrayToValue<UInt16>(
                                _currentGenesis.ReadRegister(Register.Genesisflow.CalFactor2)),
                            p3Target = 0,
                            p3Value = RegisterConverter.ByteArrayToValue<UInt16>(
                                _currentGenesis.ReadRegister(Register.Genesisflow.CalFactor3)),
                            dt = DateTime.UtcNow
                        };

                        try
                        {
                            var tmpUrl = "http://10.49.40.25/MeterProcessState/api/TestBench/SetCalibrationValues";
                            //ToDO: Update to service URl

                            t.PostAsJson<JustageResults>(tmpUrl);
                        }
                        catch (Exception)
                        {
                            //
                        }

                        /*...MF var genesisStatus = new GenesisStatus();

                        if (GenesisStatusHandler.BuildLifeTimeInformation(_currentGenesis, genesisStatus, out _))
                        {
                            var sbMSG = new StringBuilder();
                            sbMSG.AppendLine($"Pcb = {_currentGenesis.PcbId}");

                            sbMSG.AppendLine($"POWERMON_TotalUsedSeconds = {genesisStatus.ExceededLifeTime_s}");
                            sbMSG.AppendLine($"POWERMON_TotalUsedCharge = {genesisStatus.DrainedBatteryLoad_uAs}");
                            sbMSG.AppendLine($"POWERMON_BatteryQuantity = {genesisStatus.BatteryQuantity}");
                            sbMSG.AppendLine($"POWERMON_BatteryMilliAHrRating = {genesisStatus.InitialBatteryLoad_mAh}");
                            sbMSG.AppendLine("");
                            sbMSG.AppendLine($"Remaining life time in years {genesisStatus.RemainingLifeTimeYears:F2}");
                            sbMSG.AppendLine($"Totally drained battery load in % {genesisStatus.DrainedBatteryLoadPercent:F2}");

                            MessageBox.Show(sbMSG.ToString(), $@"Battery for {_currentGenesis.PcbId} has remaining life " +
                                                              $@"time of {genesisStatus.RemainingLifeTimeYears:F2} years");
                        }
                        else
                        {
                            MessageBox.Show(@"Failed to get life time information");
                        }*/
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }

                _currentGenesis.Logout();
            }
        }

        private void btnRadioPressure_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                btnRadioPressure.BackColor = Color.Yellow;
                _currentGenesis.ReLogin();
                try
                {
                    var ret = "Failed";
                    if (_currentGenesis.IsLoggedOn)
                    {

                        //CUSTOMER_AlarmEnableMask - 00-00-80-53
                        //CUSTOMER_AlarmBroadcastMask -  00-00-1F-DC
                        //CUSTOMER_AlarmVisualMask - 00-00-1F-DC
                        //

                        _currentGenesis.WriteRegister("SENSUSRADIO_MainAlarmMask", new Byte[] { 0x00 });
                        _currentGenesis.WriteRegister("SENSUSRADIO_ExtendedAlarmMask", new Byte[] { 0x00 });

                        _currentGenesis.WriteRegister("CUSTOMER_AlarmEnableMask", new Byte[] { 0xD3, 0x9F, 0x00, 0x00 });
                        _currentGenesis.WriteRegister("CUSTOMER_AlarmBroadcastMask", new Byte[] { 0xDC, 0x1F, 0x00, 0x00 });
                        _currentGenesis.WriteRegister("CUSTOMER_AlarmVisualMask", new Byte[] { 0xDC, 0x1F, 0x00, 0x00 });

                        _currentGenesis.WriteRegister("SENSUSRADIO_SystemState", 0xFF);
                        _currentGenesis.Logout();
                        Thread.Sleep(3000);
                        if (!_currentGenesis.ReLogin())
                        {
                            Thread.Sleep(5000);
                            if (!_currentGenesis.ReLogin())
                            {

                            }
                        }

                        /*var SENSUSRADIO_MainAlarmMask = */
                        _currentGenesis.ReadRegister("SENSUSRADIO_MainAlarmMask");
                        /*var SENSUSRADIO_ExtendedAlarmMask = */
                        _currentGenesis.ReadRegister("SENSUSRADIO_ExtendedAlarmMask");

                        //_currentGenesis.WriteRegister("POWERMON_BatteryQuantity", 2, true, true);

                        //var defEncryptionKey = new List<Byte>();
                        //defEncryptionKey.AddRange(new Byte[] { 0x0E, 0x9F, 0xAC, 0xC6 }.ToArray());
                        //defEncryptionKey.AddRange(new Byte[] { 0xA0, 0xE1, 0xEF, 0x1C }.ToArray());
                        //defEncryptionKey.AddRange(new Byte[] { 0x3B, 0x27, 0xA4, 0x9B }.ToArray());
                        //defEncryptionKey.AddRange(new Byte[] { 0xAC, 0x21, 0x65, 0x35 }.ToArray());
                        //_currentGenesis.WriteRegister("SENSUSRADIO_EncryptionKey", defEncryptionKey.ToArray(), true);


                        var freq = RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister("SENSUSRADIO_FrequencyIndicator"));
                        var radioAddress = RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister("SENSUSRADIO_RadioAddress"));
                        //_currentGenesis.WriteRegister("SENSUSRADIO_SystemState", 0xFF);

                        //_currentGenesis.WriteRegister("SENSUSRADIO_WakeupInterval", 0);
                        //_currentGenesis.Logout();
                        //FileConfig.AppendAllLines("RadioActivation.log", new[] { $"{freq};{_currentGenesis.PcbId};{RadioAdress};{DateTime.Now}" });
                        if (0x02 == RegisterConverter.ByteArrayToValue<Byte>(
                                _currentGenesis.ReadRegister("SENSUSRADIO_SystemState")))
                        {
                            btnRadioPressure.BackColor = Color.Green;
                            ret = $"{freq};{_currentGenesis.PcbId};{radioAddress};{DateTime.Now}";
                        }
                        else
                        {
                            btnRadioPressure.BackColor = Color.Red;

                        }
                    }

                    MessageBox.Show(ret);
                }
                catch (Exception ex)
                {
                    btnRadioPressure.BackColor = Color.Red;
                    MessageBox.Show(ex.ToString());
                }
                _currentGenesis.Logout();
            }
        }

        private void btnCalibrationRestore_Click(Object sender, EventArgs e)
        {
            //foreach (var me in _meterBatch.ListOfMeters)
            //{
            //    if (me is GenesisMeter Meter)
            //    {
            //        if (((GenesisMeter)me).IsLoggedOn)
            //        {
            //            //check if pcb is in file
            //            // no
            //            //Pcb , cal valus into txt file
            //            // cal value + 0,6
            //            // store
            //            // update Calvalues

            //            //yes
            //            //msg
            //        }
            //    }
            //}
        }

        public static Boolean GetCalibrationResultsFromDbperRun(String RunId, CalibrationResults calibResults,
                            out String errorMsg)
        {
            errorMsg = "";
            if (null == calibResults)
            {
                return false;
            }

            try
            {
                var url = "http://sla12iis01.emea.sensus.net/MeterProcessState/api/FinalCheck/CalibrationResults/";
                var requestResponse = LocalWebRequest.GetRequest(url, 30000, out var httpStatus);
                if (httpStatus == HttpStatusCode.OK && !string.IsNullOrEmpty(requestResponse))
                {
                    var calibRes = JsonConvert.DeserializeObject<CalibrationResults>(requestResponse);
                    // ClassAccess.CopyProperties(calibResults, calibRes);
                    var type = typeof(CalibrationResults);
                    foreach (var prop in type.GetProperties())
                    {
                        if (prop.CanWrite)
                            prop.SetValue(calibResults, prop.GetValue(calibRes, null), null);
                    }
                    return true;
                }
            }
            catch (Exception e)
            {
                errorMsg = e.Message;
                return false;
            }

            return false;
        }

        private void FingerWeg_Clicked(Object sender, EventArgs args)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();
                try
                {
                    if (_currentGenesis.IsLoggedOn)
                    {

                        var Meter_calibrationResult = new CalibrationResult();
                        Meter_calibrationResult.MeterSize =
                            RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.MeterSize));

                        //readsOk.Add(ReadRegisterRetry(Meter, "CalFactor1", Register.Genesisflow.CalFactor1, out retByte));
                        Meter_calibrationResult.CalFactor1 =
                            RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor1));
                        //readsOk.Add(ReadRegisterRetry(Meter, "CalFactor2", Register.Genesisflow.CalFactor2, out retByte));
                        Meter_calibrationResult.CalFactor2 =
                            RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor2));
                        //readsOk.Add(ReadRegisterRetry(Meter, "CalFactor3", Register.Genesisflow.CalFactor3, out retByte));
                        Meter_calibrationResult.CalFactor3 =
                            RegisterConverter.ByteArrayToValue<UInt32>(_currentGenesis.ReadRegister(Register.Genesisflow.CalFactor3));
                        //readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset1", Register.Genesisflow.ZeroOffset1, out retByte));
                        Meter_calibrationResult.ZeroOffset1 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset1));
                        //readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset2", Register.Genesisflow.ZeroOffset2, out retByte));
                        Meter_calibrationResult.ZeroOffset2 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset2));
                        //readsOk.Add(ReadRegisterRetry(Meter, "ZeroOffset3", Register.Genesisflow.ZeroOffset3, out retByte));
                        Meter_calibrationResult.ZeroOffset3 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ZeroOffset3));
                        //readsOk.Add(ReadRegisterRetry(Meter, "FirstHitUpdatePeriod", Register.Genesisflow.FirstHitUpdatePeriod, out retByte));
                        Meter_calibrationResult.FirstHitUpdatePeriod =
                            RegisterConverter.ByteArrayToValue<UInt16>(
                                _currentGenesis.ReadRegister(Register.Genesisflow.FirstHitUpdatePeriod));
                        //readsOk.Add(ReadRegisterRetry(Meter, "FirstHitShift", Register.Genesisflow.FirstHitShift, out retByte));
                        Meter_calibrationResult.FirstHitShift =
                            RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitShift));
                        //readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent1", Register.Genesisflow.FirstHitPercent1, out retByte));
                        Meter_calibrationResult.FirstHitPercent1 =
                            RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent1));
                        //readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent2", Register.Genesisflow.FirstHitPercent2, out retByte));
                        Meter_calibrationResult.FirstHitPercent2 =
                            RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent2));
                        //readsOk.Add(ReadRegisterRetry(Meter, "FirstHitPercent3", Register.Genesisflow.FirstHitPercent3, out retByte));
                        Meter_calibrationResult.FirstHitPercent3 =
                            RegisterConverter.ByteArrayToValue<UInt16>(_currentGenesis.ReadRegister(Register.Genesisflow.FirstHitPercent3));
                        //readsOk.Add(ReadRegisterRetry(Meter, "ToFTempOffset1", Register.Genesisflow.ToFTempOffset1, out retByte));
                        Meter_calibrationResult.ToFTempOffset1 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset1));
                        //readsOk.Add(ReadRegisterRetry(Meter, "ToFTempOffset2", Register.Genesisflow.ToFTempOffset2, out retByte));
                        Meter_calibrationResult.ToFTempOffset2 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset2));

                        Meter_calibrationResult.ToFTempOffset3 =
                            RegisterConverter.ByteArrayToValue<Int32>(_currentGenesis.ReadRegister(Register.Genesisflow.ToFTempOffset3));
                        Meter_calibrationResult.AdditionalLogInfos.Add("add info", "restore from meter");
                        var exPost = new Exception();
                        var code = 0;
                        LocalWebRequest.PostRequestAsync($"{ServiceUrls.PostGenesisCalibrationResultUrl()}?PcbId={_currentGenesis.PcbId}",
                            ref code, ref exPost, 8000, Meter_calibrationResult);
                    }
                }
                catch (Exception)
                {
                    //
                }

                //if (this._currentGenesis is null || !this._currentGenesis.IsLoggedOn)
                //{
                //    MessageBox.Show("Not connected!");

                //    return;
                //}

                //this.SetBusy(true, "Recalibration is running");

                //if (!this.CheckBatteryLifetime())
                //{
                //    this.SetBusy(false);

                //    return;
                //}

                //var p1Cal = default(int);
                //var p2Cal = default(int);
                //var p3Cal = default(int);
                //var logBuilder = new StringBuilder();

                //try
                //{
                //    var caption = string.Empty;
                //    var buttons = MessageBoxButtons.YesNo;
                //    var icon = MessageBoxIcon.Question;

                //    int ReadRegister(string name)
                //    {
                //        var value = default(int);

                //        if (!this._currentGenesis.IsLoggedOn)
                //        {
                //            if (!this._currentGenesis.ReLogin())
                //            {
                //                var answer = MessageBox.Show("Relogin failed!\n\nWould you try again?", caption, buttons, icon);

                //                if (answer == DialogResult.Yes)
                //                {
                //                    value = ReadRegister(name);
                //                }
                //            }
                //        }

                //        value = RegisterConverter.ByteArrayToValue<int>(this._currentGenesis.ReadRegister(name));

                //        if (value == 0)
                //        {
                //            var answer = MessageBox.Show($"Reading: {name} failed value is - {value}!\n\nWould you try again?", caption, buttons, icon);

                //            if (answer == DialogResult.Yes)
                //            {
                //                value = ReadRegister(name);
                //            }
                //        }

                //        return value;
                //    }

                //    p1Cal = ReadRegister(Register.Genesisflow.CalFactor1);
                //    p2Cal = ReadRegister(Register.Genesisflow.CalFactor2);
                //    p3Cal = ReadRegister(Register.Genesisflow.CalFactor3);

                //    if (p1Cal == 0 || p2Cal == 0 || p3Cal == 0)
                //    {
                //        return;
                //    }

                //    logBuilder.AppendLine();
                //    logBuilder.AppendLine($"Old values:");
                //    logBuilder.AppendLine($" - P1 CalFactor: {p1Cal}");
                //    logBuilder.AppendLine($" - P2 CalFactor: {p2Cal}");
                //    logBuilder.AppendLine($" - P3 CalFactor: {p3Cal}");
                //}
                //catch (Exception eRead)
                //{
                //    MessageBox.Show($"Read exception: {eRead}");

                //    this.SetBusy(false);

                //    return;
                //}

                //var httpClient = new HttpClient();
                //var values = new List<Q3Calibration>();

                //try
                //{
                //    using (var httpResponse = await httpClient.GetAsync(ServiceUrls.GetQ3CalibrationsURI(this._currentPcbId)))
                //    {
                //        var content = await httpResponse.Content.ReadAsStringAsync();

                //        if (httpResponse.IsSuccessStatusCode)
                //        {
                //            try
                //            {
                //                values = JsonConvert.DeserializeObject<List<Q3Calibration>>(content);
                //            }
                //            catch (Exception eParse)
                //            {
                //                MessageBox.Show($"Parse exception: {eParse}");

                //                this.SetBusy(false);

                //                return;
                //            }
                //        }
                //        else
                //        {
                //            MessageBox.Show($"Error: {content}");

                //            this.SetBusy(false);

                //            return;
                //        }
                //    }
                //}
                //catch (Exception eHttp)
                //{
                //    MessageBox.Show($"Http exception: {eHttp}");

                //    this.SetBusy(false);

                //    return;
                //}

                //if (!values.Any(x => x.P1Off == -0.30001))
                //{
                //    try
                //    {
                //        var requestUri = ServiceUrls.Q3CalibrationResultURL;
                //        var requestJson = JsonConvert.SerializeObject(new Q3Calibration
                //        {
                //            PcbId = this._currentPcbId,
                //            P1Off = -0.30001,
                //            P1Cal = p1Cal,
                //            P2Off = -0.30001,
                //            P2Cal = p2Cal,
                //            P3Off = -0.30001,
                //            P3Cal = p3Cal,
                //        });
                //        var requestContent = new StringContent(requestJson, Encoding.UTF8, "application/json");

                //        using (var httpResponse = await httpClient.PostAsync(requestUri, requestContent))
                //        {
                //            var content = await httpResponse.Content.ReadAsStringAsync();

                //            if (httpResponse.IsSuccessStatusCode && int.TryParse($"{content}", out var rowsAffected))
                //            {
                //                logBuilder.AppendLine($"... old values saved!");
                //            }
                //            else
                //            {
                //                MessageBox.Show($"HTTP Error: {content}");

                //                this.SetBusy(false);

                //                return;
                //            }
                //        }
                //    }
                //    catch (Exception eHttp)
                //    {
                //        MessageBox.Show($"Http exception: {eHttp}");

                //        this.SetBusy(false);

                //        return;
                //    }
                //}

                //if (!values.Any(x => x.P1Off == 0.30001))
                //{
                //    var offset = 0D;

                //    try
                //    {
                //        offset = values
                //            .OrderByDescending(x => x.Date)
                //            .FirstOrDefault()
                //            ?.P1Off ?? 0;

                //        if (offset > 0.2)
                //        {
                //            MessageBox.Show($"Recalibration is not required!");

                //            this.SetBusy(false);

                //            return;
                //        }
                //    }
                //    catch (Exception eLinq)
                //    {
                //        MessageBox.Show($"LINQ exception: {eLinq}");
                //    }

                //    try
                //    {
                //        p1Cal = (int)Math.Round(p1Cal * (1 + 0.6 / 100), 0);
                //        p2Cal = (int)Math.Round(p2Cal * (1 + 0.6 / 100), 0);
                //        p3Cal = (int)Math.Round(p3Cal * (1 + 0.6 / 100), 0);
                //    }
                //    catch (Exception eCalc)
                //    {
                //        MessageBox.Show($"Calculation exception: {eCalc}");

                //        this.SetBusy(false);

                //        return;
                //    }

                //    try
                //    {
                //        var caption = string.Empty;
                //        var buttons = MessageBoxButtons.YesNo;
                //        var icon = MessageBoxIcon.Question;

                //        void WriteRegister(string name, int value)
                //        {
                //            if (!this._currentGenesis.IsLoggedOn)
                //            {
                //                if (!this._currentGenesis.ReLogin())
                //                {
                //                    var answer = MessageBox.Show("Relogin failed!\n\nWould you try again?", caption, buttons, icon);

                //                    if (answer == DialogResult.Yes)
                //                    {
                //                        WriteRegister(name, value);
                //                    }
                //                }
                //            }

                //            if (!this._currentGenesis.WriteRegister(name, value))
                //            {
                //                var answer = MessageBox.Show($"Writing: {name} = {value} failed!\n\nWould you try again?", caption, buttons, icon);

                //                if (answer == DialogResult.Yes)
                //                {
                //                    WriteRegister(name, value);
                //                }
                //            }
                //        }

                //        WriteRegister(Register.Genesisflow.SealDisplay, 0);
                //        WriteRegister(Register.Genesisflow.TriggerIdle, 0);
                //        WriteRegister(Register.Genesisflow.CalFactor1, p1Cal);
                //        WriteRegister(Register.Genesisflow.CalFactor2, p2Cal);
                //        WriteRegister(Register.Genesisflow.CalFactor3, p3Cal);
                //        WriteRegister(Register.Genesisflow.DisplayUnits, 0);
                //        WriteRegister(Register.Metrologyasst.FlowUnits, 4);
                //        WriteRegister(Register.Genesisflow.DisplayPow10, -6);
                //        WriteRegister(Register.Genesisflow.SealDisplay, 1);
                //        WriteRegister(Register.Genesisflow.StoreConfiguration, 1);

                //        logBuilder.AppendLine();
                //        logBuilder.AppendLine($"New values:");
                //        logBuilder.AppendLine($" - P1 CalFactor: {p1Cal}");
                //        logBuilder.AppendLine($" - P2 CalFactor: {p2Cal}");
                //        logBuilder.AppendLine($" - P3 CalFactor: {p3Cal}");
                //    }
                //    catch (Exception eWrite)
                //    {
                //        MessageBox.Show($"Write exception: {eWrite}");

                //        this.SetBusy(false);

                //        return;
                //    }

                //    var newValuesWriten = false;

                //    try
                //    {
                //        //var requestUri = ServiceUrls.Q3CalibrationResultURL;
                //        //var requestJson = JsonConvert.SerializeObject(new Q3Calibration
                //        //{
                //        //    PcbId = this._currentPcbId,
                //        //    P1Off = 0.30001,
                //        //    P1Cal = p1Cal,
                //        //    P2Off = 0.30001,
                //        //    P2Cal = p2Cal,
                //        //    P3Off = 0.30001,
                //        //    P3Cal = p3Cal,
                //        //});
                //        var requestContent = new StringContent(requestJson, Encoding.UTF8, "application/json");

                //        using (var httpResponse = await httpClient.PostAsync(requestUri, requestContent))
                //        {
                //            var content = await httpResponse.Content.ReadAsStringAsync();

                //            if (httpResponse.IsSuccessStatusCode && int.TryParse($"{content}", out var rowsAffected))
                //            {
                //                newValuesWriten = rowsAffected > 0;
                //            }
                //            else
                //            {
                //                MessageBox.Show($"HTTP Error: {content}");

                //                this.SetBusy(false);

                //                return;
                //            }
                //        }
                //    }
                //    catch (Exception eHttp)
                //    {
                //        MessageBox.Show($"HTTP exception: {eHttp}");

                //        this.SetBusy(false);

                //        return;
                //    }

                //    if (newValuesWriten)
                //    {
                //        logBuilder.AppendLine("... new values saved!");

                //        foreach (var row in this._dataTable.Rows)
                //        {
                //            if (row is DataRow dataRow && dataRow["Name"] is string registerName)
                //            {
                //                dataRow["isChecked"] = registerName == Register.Genesisflow.SealDisplay
                //                                    || registerName == Register.Genesisflow.CalFactor1
                //                                    || registerName == Register.Genesisflow.CalFactor2
                //                                    || registerName == Register.Genesisflow.CalFactor3
                //                                    || registerName == Register.Genesisflow.DisplayUnits
                //                                    || registerName == Register.Genesisflow.DisplayPow10
                //                                    || registerName == Register.Genesisflow.StoreConfiguration
                //                                    || registerName == Register.Genesisflow.TriggerIdle
                //                                    || registerName == Register.Metrologyasst.FlowUnits;
                //            }
                //        }

                //        this.btnRead_Click(sender, args);
                //    }
                //    else
                //    {
                //        MessageBox.Show($"Q3Calibration values are not saved!");

                //        this.SetBusy(false);

                //        return;
                //    }
                //}
                //else
                //{
                //    MessageBox.Show($"Already recalibrated!");

                //    this.SetBusy(false);

                //    return;
                //}

                //MessageBox.Show(logBuilder.ToString(), $"{this._currentPcbId} - successfully recalibrated", MessageBoxButtons.OK, MessageBoxIcon.Information);
                _currentGenesis.Logout();
            }
        }

        private void btnRegisterToFile_Click(Object sender, EventArgs e)
        {
            SelectPreset("All");
            var j = ReadRegisters();

            var saveFileDialog1 = new SaveFileDialog();
            saveFileDialog1.Filter = @"Register Back Up files (*.rbu)|*.rbu";
            saveFileDialog1.FilterIndex = 1;
            saveFileDialog1.RestoreDirectory = true;

            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                File.WriteAllText(saveFileDialog1.FileName, JsonConvert.SerializeObject(j));
            }
        }

        private void btnFileToRegister_Click(Object sender, EventArgs e)
        {
            if (_currentGenesis != null)
            {
                _currentGenesis.ReLogin();

                RegisterRestoreData DataShow = null;
                using (var openFileDialog = new OpenFileDialog())
                {
                    openFileDialog.Filter = @"Register Back Up files (*.rbu)|*.rbu";
                    openFileDialog.FilterIndex = 2;
                    openFileDialog.RestoreDirectory = true;

                    if (openFileDialog.ShowDialog() == DialogResult.OK)
                    {
                        //Get the path of specified file
                        var filePath = openFileDialog.FileName;

                        DataShow = JsonConvert.DeserializeObject<RegisterRestoreData>(File.ReadAllText(filePath));
                    }
                }

                var stringBuilder = new StringBuilder();
                var NotStringBuilder = new StringBuilder();
                if (DataShow != null)
                {
                    foreach (var RestoreItem in DataShow.RegisterList)
                    {
                        var meterRegisters = _currentGenesis.GetConfigRegistersDefinitions();
                        var regDef = meterRegisters.GetRegisterDefinitionByName(RestoreItem.Key);
                        var RegValue = RestoreItem.Value;


                        /*if (RestoreItem.Value != null
                            && regDef.RegisterDetail != null
                            && regDef.RegisterDetail.Privilege.Lvl8 == Access.RW
                            && regDef.DataType != typeof(RPC))
                        {
                            _currentGenesis.ReLogin();
                            var comp = _currentGenesis.ReadRegister(RestoreItem.Key);

                            if (BitConverter.ToString(RegValue) == BitConverter.ToString(comp))
                            {
                                NotStringBuilder.AppendLine(
                                    $"Register not changed ! {RestoreItem.Key} to {BitConverter.ToString(RegValue)}");
                            }
                            else
                            {
                                if (regDef.AppName == "CONFIGEXCHANGE" || regDef.AppName == "FLEXNETSERIAL" ||
                                    regDef.AppName == "FUNCTEST" || regDef.AppName == "NFC" || regDef.AppName == "TESTMANAGER")
                                {
                                    NotStringBuilder.AppendLine(
                                        $"AppBlocked ! {RestoreItem.Key} to {BitConverter.ToString(RegValue)}");
                                }
                                else
                                {
                                    stringBuilder.AppendLine(
                                        $"{RestoreItem.Key} from {BitConverter.ToString(comp)} to {BitConverter.ToString(RegValue)}");

                                    if (regDef.DataType != typeof(String))
                                        RegValue = RegValue.Reverse().ToArray();
                                    _currentGenesis.WriteRegister(RestoreItem.Key, RegValue, checkRegister: true);
                                }
                            }
                    }*///...MF 
                    }
                }

                _currentGenesis.Logout();

                //...MF MessageBox.Show(stringBuilder.ToString());
                //...MF MessageBox.Show(NotStringBuilder.ToString());
            }
        }

        private void cbxUseOfflinePwds_CheckedChanged(Object sender, EventArgs e)
        {
            cbxUseOfflinePwds.ForeColor = cbxUseOfflinePwds.Checked ? Color.Red : Color.Black;
        }
    }
}