using System;
using System.Collections.Generic;
using NUnit.Framework;
using TechTalk.SpecFlow;
using Xylem.Common.Metrology.Measurements.Consts;

namespace Xylem.Common.Metrology.Measurements.UnitTests
{
    [Binding]
    public class MeasurementsResultsSteps
    {

        private class Measurement
        {
            public UInt16 Test;
            public MeasurementRecord DutStartRecord;
            public MeasurementRecord DutStopRecord;
            public Double DutOverflowVolumeCm;
            public Double DutOverflowTimeS;
            public Double? RefVolumeCm;
            public Double? RefTimeS;
            public Int32 RequiredChannel;
            public MeasurementResults MeasurementResults;
        }

        private readonly List<Measurement> _measurementList = new List<Measurement>();

        [Given(@"Assign measurement values")]
        public void GivenAssignMeasurementValues(Table table)
        {
            try
            {
                //creation of new measurements out of feature "Given" table
                foreach (var row in table.Rows)
                {
                    var measurement = new Measurement
                    {
                        DutStartRecord = new MeasurementRecord(),
                        DutStopRecord = new MeasurementRecord()
                    };
                    if (row.ContainsKey("Test"))
                        measurement.Test = UInt16.Parse(row["Test"]);
                    //filter for missing inputs
                    if (row.ContainsKey("DutStartVolumeCm"))
                        measurement.DutStartRecord.VolumeCm = Double.Parse(row["DutStartVolumeCm"]);
                    if (row.ContainsKey("DutStopVolumeCm"))
                        measurement.DutStopRecord.VolumeCm = Double.Parse(row["DutStopVolumeCm"]);
                    if (row.ContainsKey("DutStartTimeS"))
                        measurement.DutStartRecord.TimeS = Double.Parse(row["DutStartTimeS"]);
                    if (row.ContainsKey("DutStopTimeS"))
                        measurement.DutStopRecord.TimeS = Double.Parse(row["DutStopTimeS"]);
                    if (row.ContainsKey("StartChannel"))
                        measurement.DutStartRecord.Channel = Int32.Parse(row["StartChannel"]);
                    if (row.ContainsKey("EndChannel"))
                        measurement.DutStopRecord.Channel = Int32.Parse(row["EndChannel"]);
                    if (row.ContainsKey("RequiredChannel"))
                        measurement.RequiredChannel = Int32.Parse(row["RequiredChannel"]);

                    if (row.ContainsKey("DutOverflowVolumeCm"))
                        measurement.DutOverflowVolumeCm = Double.Parse(row["DutOverflowVolumeCm"]);
                    if (row.ContainsKey("DutOverflowTimeS"))
                        measurement.DutOverflowTimeS = Double.Parse(row["DutOverflowTimeS"]);
                    if (row.ContainsKey("RefVolumeCm"))
                    {
                        if (row["RefVolumeCm"].Equals("null")) measurement.RefVolumeCm = null;
                        else measurement.RefVolumeCm = Double.Parse(row["RefVolumeCm"]);
                    }

                    if (row.ContainsKey("RefTimeS"))
                    {
                        if (row["RefTimeS"].Equals("null")) measurement.RefTimeS = null;
                        else measurement.RefTimeS = Double.Parse(row["RefTimeS"]);
                    }

                    //fill list with measurement
                    _measurementList.Add(measurement);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        [When(@"Calculate measurement results - minimal input")]
        public void WhenCalculateMeasurementResults_MinimalInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord);
            }
        }

        [When(@"Calculate measurement results - over flow volume input")]
        public void WhenCalculateMeasurementResults_OverFlowVolumeInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord, measurement.DutOverflowVolumeCm);
            }
        }

        [When(@"Calculate measurement results - over flow time input")]
        public void WhenCalculateMeasurementResults_OverFlowTimeInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord, accuDutOverflowTimeS: measurement.DutOverflowTimeS);
            }
        }

        [When(@"Calculate measurement results - ref volume input")]
        public void WhenCalculateMeasurementResults_RefVolumeInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord, refVolumeCm: measurement.RefVolumeCm);
            }
        }

       [When(@"Calculate measurement results - channel input")]
        public void WhenCalculateMeasurementResults_ChannelInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord, requiredChannel: measurement.RequiredChannel);
            }
        }

        [When(@"Calculate measurement results - full input")]
        public void WhenCalculateMeasurementResults_FullInput()
        {
            foreach (var measurement in _measurementList)
            {
                measurement.MeasurementResults = new MeasurementResults(measurement.DutStartRecord,
                    measurement.DutStopRecord, measurement.DutOverflowVolumeCm, measurement.DutOverflowTimeS,
                    measurement.RefVolumeCm, measurement.RefTimeS, measurement.RequiredChannel);
            }
        }

        [Then(@"Test measurement results")]
        public void ThenTestMeasurementResultsFullInput(Table table)
        {
            try
            {
                foreach (var row in table.Rows)
                {
                    if (row.ContainsKey("Test"))
                    {
                        var index = UInt16.Parse(row["Test"]);
                        Assert.AreEqual(index, _measurementList[index].Test, "Wrong test number");

                        if (row.ContainsKey("DutVolumeCm"))
                            Assert.AreEqual(Double.Parse(row["DutVolumeCm"]),
                                _measurementList[index].MeasurementResults.DutVolumeCm, 0.001,
                                "Wrong DutVolumeCm");

                        if (row.ContainsKey("DutTimeS"))
                            Assert.AreEqual(Double.Parse(row["DutTimeS"]),
                                _measurementList[index].MeasurementResults.DutTimeS, 0.001,
                                "Wrong DutTimeS");

                        if (row.ContainsKey("DutFlowRateCmPh"))
                        {
                            if (row["DutFlowRateCmPh"].Equals("null"))
                                Assert.IsNull(_measurementList[index].MeasurementResults.DutFlowRateCmPh,
                                    "Wrong DutFlowRateCmPh");
                            else
                                Assert.AreEqual(Double.Parse(row["DutFlowRateCmPh"]),
                                    _measurementList[index].MeasurementResults.DutFlowRateCmPh, 0.001,
                                    "Wrong DutFlowRateCmPh");
                        }

                        if (row.ContainsKey("CorrDutVolumeCm"))
                            Assert.AreEqual(Double.Parse(row["CorrDutVolumeCm"]),
                                _measurementList[index].MeasurementResults.CorrectedDutVolumeCm, 0.001,
                                "Wrong CorrectedDutVolumeCm");

                        if (row.ContainsKey("RefFlowRateCmPh"))
                        {
                            if (row["RefFlowRateCmPh"].Equals("null"))
                                Assert.IsNull(_measurementList[index].MeasurementResults.RefFlowRateCmPh,
                                    "Wrong RefFlowRateCmPh");
                            else
                                Assert.AreEqual(Double.Parse(row["RefFlowRateCmPh"]),
                                    _measurementList[index].MeasurementResults.RefFlowRateCmPh, 0.001,
                                    "Wrong RefFlowRateCmPh");
                        }

                        if (row.ContainsKey("ScaleFactorRefToDut"))
                        {
                            if (row["ScaleFactorRefToDut"].Equals("null"))
                                Assert.IsNull(_measurementList[index].MeasurementResults.ScaleFactorRefToDut,
                                    "Wrong ScaleFactorRefToDut");
                            else
                                Assert.AreEqual(Double.Parse(row["ScaleFactorRefToDut"]),
                                    _measurementList[index].MeasurementResults.ScaleFactorRefToDut, 0.000001,
                                    "Wrong ScaleFactorRefToDut");
                        }

                        if (row.ContainsKey("DeviationDutToRefRel"))
                        {
                            if (row["DeviationDutToRefRel"].Equals("null"))
                                Assert.IsNull(_measurementList[index].MeasurementResults.DeviationDutToRefRel,
                                    "Wrong DeviationDutToRefRel");
                            else
                                Assert.AreEqual(Double.Parse(row["DeviationDutToRefRel"]),
                                    _measurementList[index].MeasurementResults.DeviationDutToRefRel, 0.00001,
                                    "Wrong DeviationDutToRefRel");
                        }

                        if (row.ContainsKey("DeviationDutToRefPer"))
                        {
                            if (row["DeviationDutToRefPer"].Equals("null"))
                                Assert.IsNull(_measurementList[index].MeasurementResults.DeviationDutToRefPer,
                                    "Wrong DeviationDutToRefPer");
                            else
                                Assert.AreEqual(Double.Parse(row["DeviationDutToRefPer"]),
                                    _measurementList[index].MeasurementResults.DeviationDutToRefPer, 0.001,
                                    "Wrong DeviationDutToRefPer");
                        }

                        if (row.ContainsKey("State"))
                        {
                            var requiredState = (MeasurementResultsStates)Enum.Parse(typeof(MeasurementResultsStates), row["State"]);
                            Assert.AreEqual(requiredState, _measurementList[index].MeasurementResults.State, "Unexpected state");
                        }
                    }
                }
                //clear measurement list for next test
                _measurementList.Clear();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
    }
}