using System.Collections.Generic;
using Deltares.Dam.Data;
using NUnit.Framework;

namespace Deltares.Dam.Tests.TimeSeries
{
    [TestFixture]
    public class TimeSeriesProcessorTest
    {
        #region Setup

        private class ProcessorMock : TimeSeriesProcessor
        {
        }

        private class CalculatorMock : ICalculator
        {
            public double? Calculate(params object[] args)
            {
                return 0;
            }
        }

        [TestFixtureSetUp]
        public void FixtureSetup()
        {
        }

        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
        }

        [SetUp]
        public void TestSetup()
        {
        }

        [TearDown]
        public void TestTearDown()
        {
        }

        #endregion

        [Test]
        public void ProcessSeries_SimpleInputSerie_ShouldProcessResultsInOutputSeries()
        {
            // setup
            TimeSeriesProcessor processor = new ProcessorMock();
            var inputCollection = new TimeSerieCollection
            {
                Series = new List<TimeSerie>()
                {
                    new TimeSerie()
                    {
                        ParameterId = "Waterpressure",
                        LocationId = "Sensor1",
                        Entries = new List<TimeSerieEntry>()
                        {
                            new TimeSerieEntry() { Value = 1 },
                            new TimeSerieEntry() { Value = 2 }
                        }
                    }
                }
            };

            // call
            const string expectedLocationID = "LocationA";
            const string expectedParameterID = "SafetyFactory";

            processor.InputTimeSeriesCollection = inputCollection;
            processor.OutputParameters = new[] {expectedParameterID};
            processor.OutputLocations = new[] {expectedLocationID};
            processor.Calculator = new CalculatorMock();

            processor.Initialize();
            processor.Process();

            // asserts
            Assert.IsNotNull(processor.OutputTimeSeriesCollection);
            Assert.AreEqual(1, processor.OutputTimeSeriesCollection.Series.Count);
            Assert.AreEqual(2, processor.OutputTimeSeriesCollection.Series[0].Entries.Count);
            Assert.AreEqual(expectedLocationID, processor.OutputTimeSeriesCollection.Series[0].LocationId);
            Assert.AreEqual(expectedParameterID, processor.OutputTimeSeriesCollection.Series[0].ParameterId);
            Assert.AreEqual(0, processor.OutputTimeSeriesCollection.Series[0].Entries[0].Value);
        }

/*
 * TODO: fix this :)
        [Test]
        public void ProcessSeries_CombinedInputSerie_ShouldFilterAndProcessResultsInOutputSeries()
        {
            // setup
            TimeSeriesProcessor processor = new ProcessorMock();
            var inputCollection = new TimeSerieCollection
            {
                Series = new List<TimeSerie>()
                {
                    new TimeSerie()
                    {
                        ParameterId = "Foo",
                        LocationId = "Bar",
                        Entries = new List<TimeSerieEntry>()
                        {
                            new TimeSerieEntry() { Value = 1 },
                            new TimeSerieEntry() { Value = 2 },
                        }
                    },
                    new TimeSerie()
                    {
                        ParameterId = "Bar",
                        LocationId = "Foo",
                        Entries = new List<TimeSerieEntry>()
                        {
                            new TimeSerieEntry() { Value = 1 },
                            new TimeSerieEntry() { Value = 2 },
                        }
                    }
                }
            };

            // call
            const string expectedLocationID = "LocBarFoo";
            const string expectedParameterID = "ParamBarFoo";

            processor.InputTimeSeries = inputCollection;
            processor.OutputParameters = new[] {expectedParameterID};
            processor.OutputLocations = new[] {expectedLocationID};
            processor.Calculator = new CalculatorMock();
            processor.InitializeSeries();
            processor.ProcessSeries();

            // asserts
            Assert.IsNotNull(processor.OutputTimeSeries);
            Assert.AreEqual(1, processor.OutputTimeSeries.Series.Count);
            Assert.AreEqual(2, processor.OutputTimeSeries.Series[0].Entries.Count);
            Assert.AreEqual(expectedLocationID, processor.OutputTimeSeries.Series[0].LocationId);
            Assert.AreEqual(expectedParameterID, processor.OutputTimeSeries.Series[0].ParameterId);
            Assert.AreEqual(0, processor.OutputTimeSeries.Series[0].Entries[0].Value);
        }
*/

    }


}