using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
using System.Globalization;

namespace GenesisZeroFlow
{
    public partial class TemperatureFieldTempCal : Form
    {


        public static class DisplayTempCal
        {
            public static void TemperatureInputForm2Visible(Boolean visible)
            {
                if (TemperatureFieldTempCal._TemperatureFieldTempCal.InvokeRequired)
                {
                    TemperatureFieldTempCal._TemperatureFieldTempCal.Invoke((Action<Boolean>)TemperatureInputForm2Visible, visible);
                    return;
                }

                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TempField_Meter1.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.nUD_TempField_Celsius1.Visible = visible;
            }

            public static void TemperatureDisplayForm2Visible(Boolean visible)
            {
                if (TemperatureFieldTempCal._TemperatureFieldTempCal.InvokeRequired)
                {
                    TemperatureFieldTempCal._TemperatureFieldTempCal.Invoke((Action<Boolean>)TemperatureDisplayForm2Visible, visible);
                    return;
                }

                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperaturePath0.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath0.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperaturePath1.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath1.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperaturePath2.Visible = visible;
                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath2.Visible = visible;
            }

            public static void TemperatureDisplayForm2(UInt16 path, double? text, CultureInfo Culture)
            {

                try
                {
                    if (text.HasValue)
                    {
                        var resultText = text.Value.ToString("0.0000", Culture);
                        if (path == Constants.PATH0 && TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath0.Text == resultText)
                            return;
                        if (path == Constants.PATH1 && TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath1.Text == resultText)
                            return;
                        if (path == Constants.PATH2 && TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath2.Text == resultText)
                            return;

                        if (TemperatureFieldTempCal._TemperatureFieldTempCal.InvokeRequired)
                        {
                            TemperatureFieldTempCal._TemperatureFieldTempCal.Invoke((Action<UInt16, double?, CultureInfo>)TemperatureDisplayForm2, path, text, Culture);
                            return;
                        }


                        switch (path)
                        {
                            case Constants.PATH0:
                                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath0.Text = resultText;
                                break;
                            case Constants.PATH1:
                                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath1.Text = resultText;
                                break;
                            case Constants.PATH2:
                                TemperatureFieldTempCal._TemperatureFieldTempCal.l_TemperatureDispPath2.Text = resultText;
                                break;
                        }
                    }
                }
                catch (Exception)
                {
                    // MessageBox.Show("exception");
                }
            }


        }

        private static double AddTemp(ushort path, double value)
        {
            var r = 0.0;
            switch (path)
            {
                case Constants.PATH0:
                    TemperatureDispPath0.Add(value);
                    if (TemperatureDispPath0.Count > 20)
                    {
                        TemperatureDispPath0.RemoveAt(0);
                    }

                    if (!TemperatureDispPath0.Any())
                    {
                        return -100;
                    }
                    TemperatureDispPath0.ForEach(a => r = r + a);
                    r = r / TemperatureDispPath0.Count;
                    break;

                case Constants.PATH1:
                    TemperatureDispPath1.Add(value);
                    if (TemperatureDispPath1.Count > 20)
                    {
                        TemperatureDispPath1.RemoveAt(0);
                    }
                    if (!TemperatureDispPath1.Any())
                    {
                        return -100;
                    }
                    TemperatureDispPath1.ForEach(a => r = r + a);
                    r = r / TemperatureDispPath1.Count;
                    break;
                case Constants.PATH2:
                    TemperatureDispPath2.Add(value);
                    if (TemperatureDispPath2.Count > 20)
                    {
                        TemperatureDispPath2.RemoveAt(0);
                    }
                    if (!TemperatureDispPath2.Any())
                    {
                        return -100;
                    }
                    TemperatureDispPath2.ForEach(a => r = r + a);
                    r = r / TemperatureDispPath2.Count;
                    break;

            }

            return r;


        }

        public TemperatureFieldTempCal()
        {
            InitializeComponent();
            _TemperatureFieldTempCal = this;
            tmrUpdateTemp.Enabled = true;
        }

        public static TemperatureFieldTempCal _TemperatureFieldTempCal;


        static List<double> TemperatureDispPath0 = new List<double>();
        static List<double> TemperatureDispPath1 = new List<double>();
        static List<double> TemperatureDispPath2 = new List<double>();



        public Double GetValueMeter1()
        {
            return (Double)nUD_TempField_Celsius1.Value;
        }

        public void SetEnabledGbLogging(Boolean enabled)
        {
            gB_Logging.Enabled = enabled;
        }

        private void btn_TempField_OK_Click(object sender, EventArgs e)
        {
            cB_Logging.Checked = false;
            TemperatureFieldTempCal._TemperatureFieldTempCal.Close();
            frmTempCalibration._frmTempCalibration.SetWaitForTemperatureFieldTempCal(false);
        }

        private void TemperatureFieldTempCal_Load(object sender, EventArgs e)
        {
            frmTempCalibration._frmTempCalibration.ThirdFormOpenIndicator = true;
            Thread.CurrentThread.CurrentCulture = frmTempCalibration._frmTempCalibration.GetGlobalCulture();
            nUD_TempField_Celsius1.Value = (Decimal)((Double)nUD_TempField_Celsius1.Value + 0.01);
            nUD_TempField_Celsius1.Value = (Decimal)((Double)nUD_TempField_Celsius1.Value - 0.01);
            TemperatureFieldTempCal.DisplayTempCal.TemperatureInputForm2Visible(frmTempCalibration._frmTempCalibration.GetAdjustmentSelectedStatus());
            TemperatureFieldTempCal.DisplayTempCal.TemperatureDisplayForm2Visible(frmTempCalibration._frmTempCalibration.GetMeasurementSelectedStatus());


            if (frmTempCalibration._frmTempCalibration.GetMeasurementSelectedStatus())
                this.Text = "SENSUS Hannover - TEMPERATURE MEASUREMENT";
            else
                this.Text = "SENSUS Hannover - TEMPERATURE ADJUSTMENT";
            l_LoggingStatus.Text = "Status: Logging not yet started";
        }

        private void TemperatureFieldTempCal_FormClosing(object sender, FormClosingEventArgs e)
        {
            tmrUpdateTemp.Enabled = false;
            frmTempCalibration._frmTempCalibration.SetWaitForTemperatureFieldTempCal(false);
            Misc.WaitNMilliseconds(100);
            frmTempCalibration._frmTempCalibration.ThirdFormOpenIndicator = false;


            //TemperatureFieldTempCal._TemperatureFieldTempCal.Close();

        }

        private void nUD_TempField_Celsius1_KeyDown(object sender, KeyEventArgs e)
        {
            LevaeFormOnEnterIsPressed(sender, e);
        }

        private void TemperatureFieldTempCal_KeyDown(object sender, KeyEventArgs e)
        {
            LevaeFormOnEnterIsPressed(sender, e);
        }

        private void LevaeFormOnEnterIsPressed(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                btn_TempField_OK_Click(sender, EventArgs.Empty);
            }
        }

        private void nUD_TempField_Celsius1_ValueChanged(object sender, EventArgs e)
        {
            //if (sender is NumericUpDown)
            //{
            //    var NumericUpDownSender = (NumericUpDown)sender;
            //}
        }

        private void nUD_TempField_Celsius1_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar.Equals('.') || e.KeyChar.Equals(','))
            {
                e.KeyChar = '.';
            }
        }

        String TemperatureLoggingPath = String.Empty;

        private void cB_Logging_CheckedChanged(object sender, EventArgs e)
        {
            CultureInfo Culture = frmTempCalibration._frmTempCalibration.GetGlobalCulture();
            DateTime Time = System.DateTime.Now;
            String Logfiletime = Time.ToString(Formats.LogFileDateTimeString, Culture);
            String Headertime = Time.ToString(Formats.HeaderFileDateTimeString, Culture);
            String Statustime = Time.ToString(Formats.HeaderFileDateTimeString, Culture);

            if (cB_Logging.Checked)
            {

                TemperatureLoggingPath = $@"..\TemperatureCalibrator_TemperatureLogging_{Logfiletime}.txt";
                String Header = $"Genesis Temperature Calibrator ; Date = {Headertime}; Operator = {Environment.UserName}\n";
                frmTempCalibration._frmTempCalibration.SetDataToLog(Header);
                l_LoggingStatus.Text = $"Status: Logging started at {Statustime}";
                frmTempCalibration._frmTempCalibration.SetLoggingIndicatorTempTest(true);
            }
            else
            {
                frmTempCalibration._frmTempCalibration.SetLoggingIndicatorTempTest(false);
                l_LoggingStatus.Text = $"Status: Logging stopped at {Statustime}";
                Logging.WriteToFile(frmTempCalibration._frmTempCalibration.GetDataToLog(), TemperatureLoggingPath);
                frmTempCalibration._frmTempCalibration.SetDataToLog(String.Empty);
            }
        }

        private void tmrUpdateTemp_Tick(object sender, EventArgs e)
        {
            CultureInfo Culture = frmTempCalibration._frmTempCalibration.GetGlobalCulture();


            var DecodedAllMeters = frmTempCalibration._frmTempCalibration.GetDecodedAllMeters();

            for (ushort Path = 0; Path < 3; Path++)
            {
                if (frmTempCalibration._frmTempCalibration.GetAdjustmentSelectedStatus())
                    frmTempCalibration.DisplayTempCal.TempCalSetTemperatureLabel(Path, Math.Round(DecodedAllMeters[Path].TemperatureDegC, 5).ToString("0.00", Culture));
                else
                {
                    if (frmTempCalibration._frmTempCalibration.ThirdFormOpenIndicator)
                        TemperatureFieldTempCal.DisplayTempCal.TemperatureDisplayForm2(Path, Math.Round(DecodedAllMeters[Path].TemperatureDegC, 5), Culture);
                }
            }

            frmTempCalibration._frmTempCalibration.FlushBuffer();

        }
    }
}