// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the application DAM - UI.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using Deltares.Dam.Data;
using Deltares.Dam.Data.Assemblers;
using Deltares.Standard;
using Deltares.Standard.IO.DtoAssembler;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class TimeSeriesAssemblerTest
    {
        #region Setup/Teardown

        [SetUp]
        public void TestSetup()
        {
            this.assembler = new TimeSeriesAssembler();
        }

        #endregion

        private const string testFileName = @"TestData\HoekscheWaard\input_dam.xml";
        private const double Precision = 1e-8;
        private XDocument testDoc;
        private TimeSeriesAssembler assembler;

        [TestFixtureSetUp]
        public void TestFixtureSetup()
        {
            this.testDoc = XDocument.Load(testFileName);
        }

        [Test]
        public void CreateDtoFromEntity()
        {
            TimeSerieCollection timeSerieCollection = new TimeSerieCollection();

            timeSerieCollection.TimeZone = 4.75;
            timeSerieCollection.Version = "1.2";

            TimeSerie timeSerie = new TimeSerie();
            timeSerie.Type = "accumulative";
            timeSerie.LocationId = "LLANFAIR-04";
            timeSerie.ParameterId = "Train speed";
            timeSerie.TimeStep.Unit = TimeStepUnit.Hour;
            timeSerie.TimeStep.Multiplier = 12;
            timeSerie.TimeStep.Divider = 60;
            timeSerie.StartDateTime = new DateTime(2009, 4, 13, 11, 51, 42);
            timeSerie.EndDateTime = new DateTime(2009, 5, 18, 22, 04, 16);
            timeSerie.MissVal = 82.9;
            timeSerie.LongName = "Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch";
            timeSerie.StationName = "Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch Railway Station";
            timeSerie.Units = "mph";
            timeSerie.SourceOrganisation = "British Rail";
            timeSerie.SourceSystem = "British railroad system";
            timeSerie.FileDescription = "Llanfair trains";
            timeSerie.CreationDateTime = new DateTime(2009, 6, 3, 11, 54, 17);
            timeSerie.Region = "North Wales";

            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 4, 13, 11, 51, 42), Value = 103.7, Flag = 0});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 4, 13, 12, 51, 42), Value = 88.4, Flag = 1});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 4, 13, 13, 51, 42), Value = 120.53, Flag = 1});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 4, 13, 14, 51, 42), Value = 108.5, Flag = 2});

            timeSerie.Comment = "Who knows how to pronounce Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch?";

            timeSerieCollection.Series.Add(timeSerie);

            timeSerie = new TimeSerie();
            timeSerie.Type = "instantaneous";
            timeSerie.LocationId = "GORSAF-13";
            timeSerie.ParameterId = "Bus speed";
            timeSerie.TimeStep.Unit = TimeStepUnit.Minute;
            timeSerie.TimeStep.Multiplier = 18;
            timeSerie.TimeStep.Divider = 35;
            timeSerie.StartDateTime = new DateTime(2009, 3, 29, 13, 4, 17);
            timeSerie.EndDateTime = new DateTime(2009, 5, 4, 8, 52, 37);
            timeSerie.MissVal = 109.17;

            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 4, 17), Value = 45.7, Flag = 0});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 5, 17), Value = 55.4, Flag = 1});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 6, 17), Value = 80.57, Flag = 1});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 7, 17), Value = 120.45, Flag = 3});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 8, 17), Value = 108.45, Flag = 1});
            timeSerie.Entries.Add(new TimeSerieEntry
                                      {DateTime = new DateTime(2009, 3, 29, 13, 9, 17), Value = 115.6, Flag = 2});

            timeSerieCollection.Series.Add(timeSerie);

            // Do the thing: create XML document from TimeSeries
            XDocument doc = this.assembler.CreateDataTransferDocument(timeSerieCollection);

            // Save XML for viewing purposes
            Directory.CreateDirectory(@"TestResults");
            doc.Save(@"TestResults\TestSeriesTestOut.xml");

            // Validate against schema
            string message;
            if (!this.assembler.ValidateSchema(doc, out message))
            {
                Assert.Fail("SCHEMA VALIDATION: " + message);
            }

            XNamespace tns = this.assembler.ElementNamespace;

            // Version
            Assert.AreEqual("1.2", doc.Root.AttributeAs<string>(TimeSeriesAssembler.XmlVersionAttributeName));

            // Time zone
            Assert.AreEqual(4.75,
                            Double.Parse(doc.Root.Element(tns + TimeSeriesAssembler.XmlTimeZoneElementName).Value,
                                         CultureInfo.InvariantCulture));

            // Series
            XElement[] serieElements = doc.Root.Elements(tns + TimeSeriesAssembler.XmlSeriesElementName).ToArray();

            Assert.AreEqual(2, serieElements.Count());

            XElement headerElement = serieElements[0].Element(tns + TimeSeriesAssembler.XmlHeaderElementName);

            // Header (0)
            Assert.AreEqual("accumulative", headerElement.Element(tns + TimeSeriesAssembler.XmlTypeElementName).Value);
            Assert.AreEqual("LLANFAIR-04",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlLocationIdElementName).Value);
            Assert.AreEqual("Train speed",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlParameterIdElementName).Value);
            XElement timeStepElement = headerElement.Element(tns + TimeSeriesAssembler.XmlTimeStepElementName);
            Assert.AreEqual("hour", timeStepElement.AttributeAs<string>(TimeSeriesAssembler.XmlUnitAttributeName));
            Assert.AreEqual(60, timeStepElement.AttributeAs<uint>(TimeSeriesAssembler.XmlDividerAttributeName));
            Assert.AreEqual(12, timeStepElement.AttributeAs<uint>(TimeSeriesAssembler.XmlMultiplierAttributeName));
            XElement startDateElement = headerElement.Element(tns + TimeSeriesAssembler.XmlStartDateElementName);
            Assert.AreEqual("2009-04-13", startDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("11:51:42", startDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            XElement endDateElement = headerElement.Element(tns + TimeSeriesAssembler.XmlEndDateElementName);
            Assert.AreEqual("2009-05-18", endDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("22:04:16", endDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(82.9,
                            Double.Parse(headerElement.Element(tns + TimeSeriesAssembler.XmlMissValElementName).Value,
                                         CultureInfo.InvariantCulture));
            Assert.AreEqual("Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlLongNameElementName).Value);
            Assert.AreEqual("Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch Railway Station",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlStationNameElementName).Value);
            Assert.AreEqual("mph", headerElement.Element(tns + TimeSeriesAssembler.XmlUnitsElementName).Value);
            Assert.AreEqual("British Rail",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlSourceOrganisationElementName).Value);
            Assert.AreEqual("British railroad system",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlSourceSystemElementName).Value);
            Assert.AreEqual("Llanfair trains",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlFileDescriptionElementName).Value);
            Assert.AreEqual("2009-06-03",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlCreationDateElementName).Value);
            Assert.AreEqual("11:54:17",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlCreationTimeElementName).Value);
            Assert.AreEqual("North Wales", headerElement.Element(tns + TimeSeriesAssembler.XmlRegionElementName).Value);

            // Entries (0)
            XElement[] entryElements =
                serieElements[0].Elements(tns + TimeSeriesAssembler.XmlEntryElementName).ToArray();

            Assert.AreEqual(4, entryElements.Count());

            Assert.AreEqual("2009-04-13", entryElements[0].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("11:51:42", entryElements[0].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(103.7, entryElements[0].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(0, entryElements[0].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-04-13", entryElements[1].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("12:51:42", entryElements[1].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(88.4, entryElements[1].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(1, entryElements[1].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-04-13", entryElements[2].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:51:42", entryElements[2].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(120.53, entryElements[2].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(1, entryElements[2].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-04-13", entryElements[3].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("14:51:42", entryElements[3].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(108.5, entryElements[3].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(2, entryElements[3].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));

            // Comment (0)
            Assert.AreEqual("Who knows how to pronounce Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch?",
                            serieElements[0].Element(tns + TimeSeriesAssembler.XMLCommentElementName).Value);

            headerElement = serieElements[1].Element(tns + TimeSeriesAssembler.XmlHeaderElementName);

            // Header (1)
            Assert.AreEqual("instantaneous", headerElement.Element(tns + TimeSeriesAssembler.XmlTypeElementName).Value);
            Assert.AreEqual("GORSAF-13", headerElement.Element(tns + TimeSeriesAssembler.XmlLocationIdElementName).Value);
            Assert.AreEqual("Bus speed",
                            headerElement.Element(tns + TimeSeriesAssembler.XmlParameterIdElementName).Value);
            timeStepElement = headerElement.Element(tns + TimeSeriesAssembler.XmlTimeStepElementName);
            Assert.AreEqual("minute", timeStepElement.AttributeAs<string>(TimeSeriesAssembler.XmlUnitAttributeName));
            Assert.AreEqual(35, timeStepElement.AttributeAs<uint>(TimeSeriesAssembler.XmlDividerAttributeName));
            Assert.AreEqual(18, timeStepElement.AttributeAs<uint>(TimeSeriesAssembler.XmlMultiplierAttributeName));
            startDateElement = headerElement.Element(tns + TimeSeriesAssembler.XmlStartDateElementName);
            Assert.AreEqual("2009-03-29", startDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:04:17", startDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            endDateElement = headerElement.Element(tns + TimeSeriesAssembler.XmlEndDateElementName);
            Assert.AreEqual("2009-05-04", endDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("08:52:37", endDateElement.AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(109.17,
                            Double.Parse(headerElement.Element(tns + TimeSeriesAssembler.XmlMissValElementName).Value,
                                         CultureInfo.InvariantCulture));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlLongNameElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlStationNameElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlUnitsElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlSourceOrganisationElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlSourceSystemElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlFileDescriptionElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlCreationDateElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlCreationTimeElementName));
            Assert.IsNull(headerElement.Element(tns + TimeSeriesAssembler.XmlRegionElementName));

            // Entries (1)
            entryElements = serieElements[1].Elements(tns + TimeSeriesAssembler.XmlEntryElementName).ToArray();

            Assert.AreEqual(6, entryElements.Count());

            Assert.AreEqual("2009-03-29", entryElements[0].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:04:17", entryElements[0].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(45.7, entryElements[0].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(0, entryElements[0].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-03-29", entryElements[1].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:05:17", entryElements[1].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(55.4, entryElements[1].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(1, entryElements[1].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-03-29", entryElements[2].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:06:17", entryElements[2].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(80.57, entryElements[2].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(1, entryElements[2].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-03-29", entryElements[3].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:07:17", entryElements[3].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(120.45, entryElements[3].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(3, entryElements[3].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-03-29", entryElements[4].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:08:17", entryElements[4].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(108.45, entryElements[4].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(1, entryElements[4].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));
            Assert.AreEqual("2009-03-29", entryElements[5].AttributeAs<string>(TimeSeriesAssembler.XmlDateAttributeName));
            Assert.AreEqual("13:09:17", entryElements[5].AttributeAs<string>(TimeSeriesAssembler.XmlTimeAttributeName));
            Assert.AreEqual(115.6, entryElements[5].AttributeAs<double>(TimeSeriesAssembler.XmlValueAttributeName));
            Assert.AreEqual(2, entryElements[5].AttributeAs<int>(TimeSeriesAssembler.XmlFlagAttributeName));

            // Comment (1)
            Assert.IsNull(serieElements[1].Element(tns + TimeSeriesAssembler.XMLCommentElementName));
        }

        [Test]
        public void CreateEntityFromDto()
        {
            // First validate test XML against schema
            double tolerance = 0.001;
            string message;
            if (!this.assembler.ValidateSchema(this.testDoc, out message))
            {
                Assert.Fail("SCHEMA VALIDATION: " + message);
            }

            XNamespace tns = this.assembler.ElementNamespace;

            // Do the thing: create TimeSeries from XML element
            TimeSerieCollection timeSerieCollection = assembler.CreateDomainObject(this.testDoc);

            Assert.IsNotNull(timeSerieCollection);

            // TimeSeries itself
            Assert.AreEqual("1.2", timeSerieCollection.Version, "Version");

            Assert.AreEqual(0.0, timeSerieCollection.TimeZone, "TimeZone", Precision);

            // Number of series
            Assert.AreEqual(8, timeSerieCollection.Series.Count, "Number of series");

            TimeSerie timeSerie = timeSerieCollection.Series[0];

            // TimeSerie
            Assert.AreEqual("instantaneous", timeSerie.Type);
            Assert.AreEqual("LOC1", timeSerie.LocationId);
            Assert.AreEqual("Waterlevel", timeSerie.ParameterId);
            Assert.AreEqual("second", timeSerie.TimeStep.Unit.ToString().ToLower());
            Assert.AreEqual(1, timeSerie.TimeStep.Divider);
            Assert.AreEqual(3600, timeSerie.TimeStep.Multiplier);
            Assert.AreEqual("2009-06-17 08:00:00", timeSerie.StartDateTime.ToString("yyyy-MM-dd HH:mm:ss"));
            Assert.AreEqual("2009-06-18 08:00:00", timeSerie.EndDateTime.ToString("yyyy-MM-dd HH:mm:ss"));
            Assert.AreEqual(-999.0, timeSerie.MissVal);
            Assert.IsNull(timeSerie.LongName);
            Assert.AreEqual("point 1", timeSerie.StationName);
            Assert.AreEqual("m", timeSerie.Units);
            Assert.IsNull(timeSerie.SourceOrganisation);
            Assert.IsNull(timeSerie.SourceSystem);
            Assert.IsNull(timeSerie.FileDescription);
            Assert.IsNull(timeSerie.CreationDateTime);
            Assert.IsNull(timeSerie.Region);

            // Number of entries
            Assert.AreEqual(25, timeSerie.Entries.Count, "Number of entries");

            Assert.AreEqual("2009-06-17 08:00:00", timeSerie.Entries[0].DateTime.ToString("yyyy-MM-dd HH:mm:ss"));
            Assert.AreEqual(2.32, timeSerie.Entries[0].Value, tolerance);
            Assert.AreEqual(0, timeSerie.Entries[0].Flag);

            // Comment
            Assert.IsNull(timeSerie.Comment);
        }
    }
}