using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Xylem.Common.Hardware.WaterMeter.MagFlux.DataPackages.DataTypes;
using Xylem.Common.Hardware.WaterMeter.MagFlux.DataPackages.EventArguments;
using Xylem.Common.Hardware.WaterMeter.MagFlux.MagFluxCore;
using Xylem.Common.Hardware.WaterMeter.WaterMeterCore;
using Xylem.Common.Utils.ProcessExec.EventArguments;


namespace Xylem.Common.Ui.MagFluxToolBox
{
    /// <summary>
    /// Test form for MagFlux operation
    /// </summary>
    public partial class FrmTest : Form
    {
        #region Variables

        const String headerRef = @"Ref FlowRate [m³/h]";
        const String headerDut = @"DUT FlowRate [m³/h]";

        /// <summary>
        /// Reference to list of calibration points in cubic meters per hour.
        /// </summary>
        private List<Calibration> _calibPointsCmPerH;

        private DataTable _dataTableCalibPoints;

        private readonly MeterBatch _meterBatch = new MeterBatch();
        private MagFluxMeter _magFluxMeter;
        private const String StrConnecting = "Connecting to PCB";
        private const String StrNotConnected = "NOT CONNECTED";
        private const String StrOverallProcess = "Overall Process";

        private String _lastState;
        private Int32 _lastSingleProgress;
        private DateTimeOffset _startTime;
        private Boolean _resetTimeMeasurement;
        private readonly Boolean _updateGui = true;

        private Boolean _tryConnectPcb;

        // external update remarks form
        // private readonly FrmHistory _frmHistory = new FrmHistory();

        private readonly Version _version;

        // marker for initial connection to update information just needed once
        private Boolean _initialConnect;

        // status information
        private static readonly Color ColorDefault = Color.Black;
        private static readonly Color ColorSuccess = Color.Green;
        private static readonly Color ColorProcessFailed = Color.Red;
        //private static readonly Color ColorOngoingProcess = Color.Blue;
        //private static readonly Color ColorUnknownStatus = Color.Gray;
        //private const String SuccessSign = @"✔";
        //private const String FailedSign = @"✘";

        private const String StrSeparator = "-----------------------------------------------------" +
                                            "-----------------------------------------------------";
        #endregion

        #region FormControls
        /// <summary>
        /// Ctor FW update
        /// </summary>
        public FrmTest()
        {
            InitializeComponent();
            var cultureInfo = new CultureInfo("en-GB");
            Thread.CurrentThread.CurrentUICulture = cultureInfo;
            Thread.CurrentThread.CurrentCulture = cultureInfo;
            _version = Assembly.GetExecutingAssembly().GetName().Version;
        }

        /// <summary>
        /// Clear data table and set genesis to not connected
        /// </summary>
        private void Init()
        {
            ProcessViewControl(false);
            _magFluxMeter?.StopStreamingCatcher();
            lblSensorNo.Text = StrNotConnected;
            lblSensorNo.ForeColor = Color.Red;
            lblWaitingForMeterResponse.Visible = false;
            btnConnect.Enabled = true;
            SetControlDownloadsLocked();
            _initialConnect = true;
            tbxUniqueId.Text = "";
            tbxSensorNo.Text = "";
            tbxFwVersion.Text = "";
            tbxFwBuildDate.Text = "";
            tbxFwGitHash.Text = "";
            tbxMeterSize.Text = "";
            tbxFlowRate.Text = "";
            tbxStatus.Text = "";
            tbxVolume.Text = "";
            tbxRevVolume.Text = "";
        }

        private void FrmTest_Load(Object sender, EventArgs e)
        {
            var version = Assembly.GetExecutingAssembly().GetName().Version;
            lblFwUpdateInfo.Text = $@"Version: {version.Major}.{version.Minor}.{version.Build}";
            _resetTimeMeasurement = true;
            Init();

            LogText($"MagFluxToolBox: {_version.Major}.{_version.Minor}.{_version.Build}");
            LogText(StrSeparator);
        }

        private void FrmTest_FormClosing(Object sender, FormClosingEventArgs e)
        {
            if (_magFluxMeter != null)
            {
                _magFluxMeter.OnStreamingRecordDecoded -= StreamingCatcher_OnStreamingRecordDecoded;
                _magFluxMeter.Logout();
                _magFluxMeter.StopStreamingCatcher();

            }
            _meterBatch?.RemoveAllMeters();
            _meterBatch?.Dispose();

            Dispose();
        }

        private void cbComSlot_SelectedIndexChanged(Object sender, EventArgs e)
        {
            _resetTimeMeasurement = true;
            Init();
        }
        #endregion
        #region ------------------------------------------ Data Grid Calibration --------------------------------------
        /// <summary>
        /// Edit calibrations and fill the data back to calibration data field
        /// </summary>
        /// <remarks date="2023-Mai-31" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        private void gridViewCalib_CellEndEdit(Object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                if (e.ColumnIndex < 0 || e.RowIndex < 0 || _dataTableCalibPoints == null
                    || _calibPointsCmPerH == null || _calibPointsCmPerH.Count < e.RowIndex)
                {
                    return;
                }

                var array = _calibPointsCmPerH.ToArray();
                var index = e.RowIndex;
                _calibPointsCmPerH.Clear();
                var cellContent = gridViewCalib.Rows[e.RowIndex].Cells[e.ColumnIndex].Value;

                if (gridViewCalib.Columns[e.ColumnIndex].Name == headerRef)
                    array[index].refFlowRate = (Single)cellContent;

                if (gridViewCalib.Columns[e.ColumnIndex].Name == headerDut)
                    array[index].dutFlowRate = (Single)cellContent;

                var ordered = array.OrderBy(x => x.refFlowRate);
                foreach (var a in ordered)
                {
                    _calibPointsCmPerH.Add(a);
                }

                FillDataGridWithCalibInfos();
                    
            }
            catch (Exception)
            {
                // ignored
            }
        }
        /// <summary>
        /// Build data grid for calibrations
        /// </summary>
        /// <remarks date="2023-Mai-31" author="Thomas Wiedebusch">
        /// - Initial.
        /// </remarks>
        private void FillDataGridWithCalibInfos()
        {

            if (_calibPointsCmPerH == null)
                return;

            _dataTableCalibPoints?.Dispose();
            _dataTableCalibPoints = new DataTable();

            _dataTableCalibPoints.Columns.Add(headerRef, typeof(Single));
            _dataTableCalibPoints.Columns.Add(headerDut, typeof(Single));

            try
            {
                foreach (var cb in _calibPointsCmPerH)
                {
                    var row = _dataTableCalibPoints.NewRow();
                    row[headerRef] = cb.refFlowRate;
                    row[headerDut] = cb.dutFlowRate;

                    _dataTableCalibPoints.Rows.Add(row);
                }

                gridViewCalib.DataSource = _dataTableCalibPoints;

                foreach (DataGridViewColumn column in gridViewCalib.Columns)
                {
                    column.SortMode = DataGridViewColumnSortMode.NotSortable;
                }
            }
            catch (Exception)
            {
                //not implemented
            }
        }
        #endregion --------------------------------------- Data Grid Calibration --------------------------------------

        #region ActivationControls

        private void SetControlDownloadsLocked()
        {
            btnConnect.Enabled = true;
            btnAbortCalibration.Enabled = false;
            btnPrepareCalibration.Enabled = false;
            btnReadCalibration.Enabled = false;
            btnWriteCalibration.Enabled = false;
        }

        private void SetControlsDownloadIsOngoing()
        {
            btnConnect.Enabled = false;
            btnAbortCalibration.Enabled = false;
            btnPrepareCalibration.Enabled = false;
            btnReadCalibration.Enabled = false;
            btnWriteCalibration.Enabled = false;
        }

        private void SetControlsDownloadIsFinished()
        {
            btnConnect.Enabled = true;
            btnAbortCalibration.Enabled = false;
            btnPrepareCalibration.Enabled = true;
            btnReadCalibration.Enabled = true;
            btnWriteCalibration.Enabled = true;
        }
        private void SetControlsDownloadEnabled()
        {
            btnConnect.Enabled = true;
            btnAbortCalibration.Enabled = false;
            btnPrepareCalibration.Enabled = true;
            btnReadCalibration.Enabled = true;
            btnWriteCalibration.Enabled = true;
        }
        #endregion

        #region BoardControls

        /// <summary>
        ///     Cyclic execution of catcher on incoming events.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void StreamingCatcher_OnStreamingRecordDecoded(Object sender, MagFluxFlowDataEventArgs e)
        {
            Invoke(new Action(() =>
            {
                tbxVolume.Text = $@"{e.NewData.VolumeCm:F3}";
                tbxRevVolume.Text = $@"{e.NewData.RevVolumeCm:F3}";
                tbxFlowRate.Text = $@"{e.NewData.FlowRateCmPh:F3}";
                tbxStatus.Text = $@"0x{e.NewData.StatusBits:X8}";
            }));

        }


        private void Connect()
        {
            try
            {
                Init();

                if (string.IsNullOrEmpty(cbComSlot.SelectedItem.ToString()) ||
                    !int.TryParse(cbComSlot.SelectedItem.ToString(), out var slotNr))
                {
                    return;
                }

                //lblOverall.Text = @"Establish data base connection..";

                Task.Factory.StartNew(() =>
                {
                    ViewProgressPcb(true);

                    _magFluxMeter?.DisposeMeter();
                    //dispose old meter
                    _meterBatch.RemoveAllMeters();
                    _magFluxMeter = null;
                    Thread.Sleep(200);

                    //assign new meter and assign meter to FW update file if this exists
                    _magFluxMeter = new MagFluxMeter();

                    _magFluxMeter.SetupFromConfigFile(slotNr);
                    _meterBatch.AddMeter(_magFluxMeter);

                    _magFluxMeter.Configuration.UseRegisterWatchService = false;
                    _magFluxMeter.Configuration.UseMinMaxCheck = false;
                    _magFluxMeter.OnStreamingRecordDecoded += StreamingCatcher_OnStreamingRecordDecoded;

                    _meterBatch.MetersLogin();

                    Invoke(new Action(() =>
                    {
                        if (_magFluxMeter != null && _magFluxMeter.IsLoggedOn)
                        {
                            lblSensorNo.Text = "";
                            tbxUniqueId.Text = _magFluxMeter.UniqueId;
                            tbxSensorNo.Text = _magFluxMeter.PcbId;
                            tbxFwVersion.Text = _magFluxMeter.FwVersion;
                            tbxFwBuildDate.Text = _magFluxMeter.FwBuildDate;
                            tbxFwGitHash.Text = _magFluxMeter.FwGitHash;
                            tbxMeterSize.Text = _magFluxMeter.MeterSizeMm.ToString();
                            lblSensorNo.ForeColor = Color.Green;
                            CheckUpdateEnabled();
                            _magFluxMeter.StartStreamingCatcher();
                            _magFluxMeter.Logout();
                            LogInstalledMeterFw();
                        }
                    }));
                }).ContinueWith(delegate
                {
                    ViewProgressPcb(false);
                });
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                LogErrorText(ex.Message);
            }
        }
        #endregion

        #region ProcessControls
        private void ViewProgressPcb(Boolean isActive)
        {
            if (_updateGui)
            {
                if (isActive)
                {
                    Invoke(new Action(() =>
                    {
                        _tryConnectPcb = true;
                        ProcessViewControl(true);
                        lblActualProcess.Text = StrConnecting;
                        lblOverall.Text = StrOverallProcess;
                    }));
                }
                else
                {
                    Invoke(new Action(() =>
                    {
                        _tryConnectPcb = false;
                        ProcessViewControl(false);
                    }));
                }
            }
        }

        /// <summary>
        /// View all process bars and labels
        /// </summary>
        private void ProcessViewControl(Boolean view)
        {
            if (view)
            {
                lblActualProcess.Visible = true;
                lblOverall.Visible = true;
                barOverallProgressUpdate.Visible = true;
                barSingleProgressUpdate.Visible = true;
                _lastState = "";
                tmrProgressUpdate.Enabled = true;
            }
            else
            {
                lblActualProcess.Visible = false;
                lblOverall.Visible = false;
                barOverallProgressUpdate.Visible = false;
                barSingleProgressUpdate.Visible = false;
                tmrProgressUpdate.Enabled = false;
                _lastState = "";
                lblWaitingForMeterResponse.Visible = false;
                lblActualProcess.Text = "";
                lblOverall.Text = "";
            }

            //common actions and settings
            lblActualProcess.Update();
            lblOverall.Update();
            barOverallProgressUpdate.Value = 0;
            barOverallProgressUpdate.Update();
            barSingleProgressUpdate.Value = 0;
            barSingleProgressUpdate.Update();
            Update();
        }

        private void StartStopDownload(Boolean isActive)
        {
            if (isActive)
            {
                Invoke(new Action(() =>
                {
                    ProcessViewControl(true);
                    tmrProgressUpdate.Enabled = true;
                }));
            }
            else
            {
                Invoke(new Action(() =>
                {
                    ProcessViewControl(false);
                    SetControlsDownloadIsFinished();

                    //// update the display of the meter size, LUT CRC and region
                    //tbxMeterFw.Text = _magFluxMeter.FwVersion;
                    //tbxMeterMeterSize.Text = _magFluxMeter.MeterSizeMm;
                    //tbxMeterLutCrc.Text = _magFluxMeter.LutCrc;
                    //tbxRegion.Text = _magFluxMeter.Region;

                    //if (!_lutFileSuccessfulWritten)
                    //{
                    //    lblLutFileLoadedInfo.ForeColor = Color.Red;
                    //    lblLutFileLoadedInfo.Text = StrUpdateErrorMessage;
                    //    var txt = StrUpdateErrorMessage;
                    //    if (!string.IsNullOrEmpty(_meterLutUpdate?.ErrorMessage))
                    //    {
                    //        txt += "\n";
                    //        txt += _meterLutUpdate?.ErrorMessage;
                    //    }

                    //    LogErrorText(txt);
                    //    MessageBoxShow(txt, @"FAILED",
                    //        MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //}
                    //else
                    //{
                    //   LogSuccessText(StrUpdateSuccessMessage);
                    //    MessageBoxShow(StrUpdateSuccessMessage, @"SUCCESS",
                    //        MessageBoxButtons.OK, MessageBoxIcon.Information);
                    //}
                }));
            }
        }

        /// <summary>
        /// Display installed meter FW.
        /// </summary>
        /// <remarks date="2022-Mar-25" author="Thomas Wiedebusch">
        /// - Init.
        /// </remarks>
        private void LogInstalledMeterFw()
        {
            //if (_magFluxMeter == null)
            //    return;
            //LogText(StrSeparator);
            //LogText($"PCB ID: {_magFluxMeter.PcbId}");
            //LogText($"Core Version: {GenesisMeter.BuildFwVersionString(_magFluxMeter.CoreRevision)}");
            //LogText("");
            //LogText("Installed Applications:");

            //foreach (var app in _magFluxMeter.MeterAppListVersion)
            //{
            //    var versionString = app.IsInstalled ? $"V: {app.StrVersion} - CRC: 0x{app.Crc:X4}" :
            //        "App NOT Installed";
            //    LogText($"AppId: 0x{app.AppId:X2} - {versionString} - " + $"AppName: {app.AppName}");

            //    if (app.IsInstalled)
            //    {
            //        var appVersion = new CordonelAppVersion(app.AppId, app.StrVersion);

            //        // Copy metrology update permission
            //        if (app.AppName == MeterFwUpdateCapability.MetrologyName &&
            //            _magFluxMeter.MetrologyUpgradePermission != MeterFwUpdateCapability.MetrologyUpgradePermitted)
            //        {
            //            appVersion.IsUpdateable = false;
            //        }
            //    }
            //}
            //LogText(StrSeparator);
        }


        /// <summary>
        /// Output exclusively to user update remarks text window.
        /// </summary>
        /// <remarks date="2021-Apr-26" author="Thomas Wiedebusch">
        /// - Color added.
        /// </remarks>
        private void LogText(String txtHistory)
        {
            InfoWindowColoredText(txtHistory, ColorDefault);
        }

        /// <summary>
        /// Output exclusively to user update remarks text window.
        /// </summary>
        private void LogErrorText(String txtHistory)
        {
            InfoWindowColoredText(txtHistory, ColorProcessFailed);
        }

        /// <summary>
        /// Output exclusively to user update remarks text window.
        /// </summary>
        private void LogSuccessText(String txtHistory)
        {
            InfoWindowColoredText(txtHistory, ColorSuccess);
        }

        /// <summary>
        /// Output exclusively to user update remarks text window.
        /// </summary>
        private void InfoWindowColoredText(String txtHistory, Color color)
        {
            //if (_frmHistory?.rtbHistory == null)
            //    return;
            //Invoke(new Action(() =>
            //{
            //    _frmHistory.rtbHistory.SuspendLayout();
            //    _frmHistory.rtbHistory.SelectionStart = _frmHistory.rtbHistory.Text.Length;
            //    _frmHistory.rtbHistory.SelectionLength = 0;
            //    _frmHistory.rtbHistory.SelectionColor = color;
            //    _frmHistory.rtbHistory.AppendText($"{txtHistory}{Environment.NewLine}");
            //    _frmHistory.rtbHistory.SelectionColor = _frmHistory.rtbHistory.ForeColor;
            //    _frmHistory.rtbHistory.ScrollToCaret();
            //    _frmHistory.rtbHistory.ResumeLayout();
            //}));
        }
        #endregion

        #region Checks
        private void CheckUpdateEnabled()
        {
            //this check has been placed here to force display update
            if (_magFluxMeter != null)
            {
                SetControlsDownloadEnabled();
                return;
            }
            SetControlDownloadsLocked();
        }
        #endregion

        #region Events

        /// <summary>
        /// Process update event for displaying messages in history window
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <remarks date="2020-Dec-10" author="Thomas Wiedebusch">
        /// - Initial
        /// </remarks>
        public virtual void ProcessUpdate_Event(Object sender, ProcessExecEventArgs e)
        {
            LogText(e.OverallProcessMessage);
        }

        #endregion

        #region TimerControls
        private void tmrProgressUpdate_Tick(Object sender, EventArgs e)
        {
            //cbxManualControl.Visible = true;
            if (_tryConnectPcb)
            {
                barOverallProgressUpdate.Value = barOverallProgressUpdate.Value + 1 > 100 ? 0 :
                    barOverallProgressUpdate.Value + 1;
                barSingleProgressUpdate.Value = barSingleProgressUpdate.Value + 4 > 100 ? 0 :
                    barSingleProgressUpdate.Value + 4;
                lblOverall.Text = StrOverallProcess;
            }
            else
            {
                //lblOverall.Text = _meterLutUpdate?.GetLutUpdateStateOperation();
                //lblActualProcess.Text = _meterLutUpdate?.GetActualOperation();

                //var overallProgress = (Int32)(_meterLutUpdate?.OverallProcessCtrPercent ?? 0);
                //if (overallProgress < 0)
                //    overallProgress = 0;
                //barOverallProgressUpdate.Value = overallProgress > 100 ? 100 : overallProgress;
                //barOverallProgressUpdate.Update();

                //var singleProgress = (Int32)(_meterLutUpdate?.SingleFileProcessCtrPercent ?? 0);
                //if (_meterLutUpdate?.GetActualOperation() != _lastState)
                //{
                //    _lastState = _meterLutUpdate?.GetActualOperation();
                //    lblWaitingForMeterResponse.Visible = false;
                //}
                //else
                //{
                //    //if the communication gets frozen
                //    lblWaitingForMeterResponse.Visible = _lastSingleProgress == singleProgress;
                //}

                //barSingleProgressUpdate.Value = singleProgress > 100 ? 100 : singleProgress;
                //_lastSingleProgress = singleProgress;
                //barSingleProgressUpdate.Update();
            }
            SetTimeDisplay();
            Update();
        }

        private void SetTimeDisplay()
        {
            var time = DateTimeOffset.UtcNow;
            var timeSpan = time - _startTime;
            lblUpdateTime.Text = $@"{(UInt32)timeSpan.TotalMinutes}:{timeSpan.Seconds:00}";
        }
        #endregion
        #region Buttons
        private void btnPrepareCalibration_Click(Object sender, EventArgs e)
        {
            SetControlsDownloadIsOngoing();
            _magFluxMeter?.InitCalibration();
            btnAbortCalibration.Enabled = true;
            btnReadCalibration_Click(this, null);
            SetControlsDownloadIsFinished();
        }

        private void btnReadCalibration_Click(Object sender, EventArgs e)
        {
            SetControlsDownloadIsOngoing();
            _magFluxMeter?.ReadCalibration(out _calibPointsCmPerH);
            if (_calibPointsCmPerH == null) return;

            _dataTableCalibPoints?.Clear();
            FillDataGridWithCalibInfos();
            SetControlsDownloadIsFinished();
        }

        private void btnWriteCalibration_Click(Object sender, EventArgs e)
        {
            SetControlsDownloadIsOngoing();
            if (_calibPointsCmPerH == null)
                return;
 
            _magFluxMeter?.WriteCalibration(_calibPointsCmPerH);
            btnReadCalibration_Click(this, null);
        }

        private void btnAbortCalibration_Click(Object sender, EventArgs e)
        {
            _magFluxMeter?.StopCalibration();
        }

        private void btnConnect_Click(Object sender, EventArgs e)
        {
            if (_resetTimeMeasurement)
            {
                _startTime = DateTimeOffset.UtcNow;
                _resetTimeMeasurement = false;
            }
            Connect();
        }

        /// <summary>
        /// Download calibration to MagFlux
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnDownloadCalibration_Click(Object sender, EventArgs e)
        {
            if (_magFluxMeter == null)
            {
                return;
            }

            SetControlsDownloadIsOngoing();
            StartStopDownload(true);

            _startTime = DateTimeOffset.UtcNow;
            _resetTimeMeasurement = false;
        }

        #endregion
        #region ExternalCalls

        /// <summary>
        /// 
        /// </summary>
        public MsgEventArgs LastMsgEvent;

        /// <inheritdoc />
        public class MsgEventArgs : EventArgs
        {
            /// <summary>
            /// Text to display
            /// </summary>
            public String Text;
            /// <summary>
            /// Headline
            /// </summary>
            public String Caption;
            /// <summary>
            /// Buttons
            /// </summary>
            public MessageBoxButtons Buttons;
            /// <summary>
            /// Icon
            /// </summary>
            public MessageBoxIcon Icon;
        }

        /// <summary>
        /// Message pop up event handler
        /// </summary>
        public event EventHandler<MsgEventArgs> OnMsgPopUp;
        private void MessageBoxShow(String text, String caption, MessageBoxButtons buttons, MessageBoxIcon icon)
        {
            if (_updateGui)
            {
                MessageBox.Show(text, caption, buttons, icon);
            }
            else
            {
                LastMsgEvent = new MsgEventArgs() { Text = text, Caption = caption, Buttons = buttons, Icon = icon };
                OnMsgPopUp?.Invoke(this, LastMsgEvent);
            }

        }
        #endregion

    }
}