//-----------------------------------------------------------------------
// <copyright file="PLLinesCreatorDupuitTests.cs" company="Deltares">
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>31-08-2011</date>
// <summary>Write and read files to itnteract with DikeFlow.exe</summary>
//-----------------------------------------------------------------------

using Deltares.Dam.TestHelper;
using Deltares.Geotechnics;
using Deltares.Geotechnics.SurfaceLines;

namespace Deltares.Dam.Tests
{
    using System;
    using System.IO;

    using Deltares.Dam.Data;
    using NUnit.Framework;

    [TestFixture]
    public class DupuitCalculatorFileIOTest
    {
        private string filenameBase = "testfile";
        private DupuitCalculatorFileIO dupuitCalculatorFileIo;
        private SurfaceLine2 exampleSurfaceLine;
        private double cTolerance = 0.0001;

        [TestFixtureSetUp]
        public void CreateFiles()
        {
            // Cleanup previous files if present
            string[] fileEntries = Directory.GetFiles(Directory.GetCurrentDirectory(), filenameBase + ".*");
            foreach (string filename in fileEntries)
            {
                File.Delete(filename);
            }

            exampleSurfaceLine = FactoryForDupuitCalculatorTest.CreateExampleSurfaceLine();

            dupuitCalculatorFileIo = new DupuitCalculatorFileIO();
            dupuitCalculatorFileIo.Geometry2DData = FactoryForDupuitCalculatorTest.CreateExampleGeometry2D();
            dupuitCalculatorFileIo.WaterLevelTimeserie = FactoryForDupuitCalculatorTest.CreateWaterLevelTimeSerie();
            dupuitCalculatorFileIo.SafetyFactorTimeserie = FactoryForDupuitCalculatorTest.CreateSafetyFactorTimeSerie();
            dupuitCalculatorFileIo.PolderLevelTimeserie = FactoryForDupuitCalculatorTest.CreatePolderLevelTimeSerie();
            dupuitCalculatorFileIo.SoilList = FactoryForDupuitCalculatorTest.CreateSoilList();
            dupuitCalculatorFileIo.SurfaceLine = exampleSurfaceLine;
            dupuitCalculatorFileIo.DupuitCalculationOptions = new DupuitCalculationOptions();
            dupuitCalculatorFileIo.DupuitPlLinesTimeSerie = FactoryForDupuitCalculatorTest.CreateDupuitPLLinesTimeSerie();

            dupuitCalculatorFileIo.WriteInputFiles(filenameBase);
            dupuitCalculatorFileIo.WriteOutputFiles(filenameBase);
        }

        [TestFixtureTearDown]
        public void TearDown()
        {
            exampleSurfaceLine.Dispose();
        }

        [Test]
        public void CanWriteGeometryFile()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.soilLayersFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteWaterLevels()
        {
            CreateFiles();
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.waterLevelFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWritePrecipitation()
        {
            CreateFiles();
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.precipitationFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteMaterials()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.materialFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteCalculationOptions()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.calculateFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteSections()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.sectionsFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteMonitor()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.monitorFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWritePolderWaterlevel()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.polderLevelFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWriteSafetyFactors()
        {
            Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, DupuitCalculatorFileIO.safetyFactorFilenameExt)), "Expected output file(s) not present");
        }

        [Test]
        public void CanWritePLLines()
        {
            for (int timeIndex = 0; timeIndex < dupuitCalculatorFileIo.DupuitPlLinesTimeSerie.Entries.Count; timeIndex++)
            {
                string extension = String.Format("{0}{1}", DupuitCalculatorFileIO.piezoLinesFilesnameExt, timeIndex.ToString("D3"));
                Assert.IsTrue(File.Exists(Path.ChangeExtension(filenameBase, extension)), "Expected output file(s) not present");
            }
        }

        [Test]
        public void CanReadPLLines()
        {
            var dupuitCalculatorFileReader = new DupuitCalculatorFileIO();
            dupuitCalculatorFileReader.ReadOutputFiles(filenameBase);
            Assert.IsNotNull(dupuitCalculatorFileReader.DupuitPlLinesTimeSerie);
            Assert.AreEqual(dupuitCalculatorFileIo.DupuitPlLinesTimeSerie.Entries.Count, dupuitCalculatorFileReader.DupuitPlLinesTimeSerie.Entries.Count);

            for (int timeIndex = 0; timeIndex < dupuitCalculatorFileIo.DupuitPlLinesTimeSerie.Entries.Count; timeIndex++)
            {
                var sourceEntry = dupuitCalculatorFileIo.DupuitPlLinesTimeSerie.Entries[timeIndex];
                var actualEntry = dupuitCalculatorFileReader.DupuitPlLinesTimeSerie.Entries[timeIndex];
                Assert.AreEqual(sourceEntry.DupuitPlLines.PLLines.Count, actualEntry.DupuitPlLines.PLLines.Count);
                for (int lineIndex = 0; lineIndex < sourceEntry.DupuitPlLines.PLLines.Count; lineIndex++)
                {
                    for (int pointIndex = 0; pointIndex < sourceEntry.DupuitPlLines.PLLines[lineIndex].Points.Count; pointIndex++)
                    {
                        Assert.IsTrue(sourceEntry.DupuitPlLines.PLLines[lineIndex].Points[pointIndex].LocationEquals(
                            actualEntry.DupuitPlLines.PLLines[lineIndex].Points[pointIndex]));
                    }
                }
            }
        }

        [Test]
        public void CanReadSafetyFactors()
        {
            var dupuitCalculatorFileReader = new DupuitCalculatorFileIO();
            dupuitCalculatorFileReader.ReadOutputFiles(filenameBase);
            Assert.IsNotNull(dupuitCalculatorFileReader.SafetyFactorTimeserie);
            Assert.AreEqual(dupuitCalculatorFileIo.SafetyFactorTimeserie.Entries.Count, dupuitCalculatorFileReader.SafetyFactorTimeserie.Entries.Count);

            for (int safetyFactorIndex = 0; safetyFactorIndex < dupuitCalculatorFileIo.SafetyFactorTimeserie.Entries.Count; safetyFactorIndex++)
            {
                // DatTime of the entries are not equal because with DikeFlow we start with 0
                Assert.AreEqual(dupuitCalculatorFileIo.SafetyFactorTimeserie.Entries[safetyFactorIndex].Value,
                    dupuitCalculatorFileReader.SafetyFactorTimeserie.Entries[safetyFactorIndex].Value, cTolerance);
            }

        }
    }
}