// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero 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.Collections.Generic;
using System.IO;
using System.Linq;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
using NUnit.Framework;
using Deltares.MacroStability.Kernel;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.TestHelpers.Factories;
using Deltares.MacroStability.Data;
using Deltares.MacroStability.Geometry;
using Deltares.MacroStability.Standard;
using Deltares.SoilStress.Data;
using KellermanSoftware.CompareNetObjects;
using CharacteristicPointSet = Deltares.MacroStability.Geometry.CharacteristicPointSet;
using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
using HeadLine = Deltares.DamEngine.Data.Geometry.HeadLine;
using Soil = Deltares.MacroStability.Geometry.Soil;
using SoilProfile2D = Deltares.DamEngine.Data.Geotechnics.SoilProfile2D;
using SurfaceLine2 = Deltares.DamEngine.Data.Geotechnics.SurfaceLine2;
using Waternet = Deltares.MacroStability.Geometry.Waternet;

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon
{
    [TestFixture]
    public class MacroStabilityIoTests
    {
        private const string WtiFilesMap = @"KernelWrappers\MacroStabilityCommon\TestFiles";

        private static readonly List<string> SoilParametersToIgnore = new List<string>()
        {
            "StrengthIncreaseExponent",
            "RRatio",
            "RheologicalCoefficient",
            "BondStressCurve",
            "UseSoilType"
        };

        [TestCase("Benchmark 1-01b.wti")]
        [TestCase("Benchmark 2-04a.wti")]
        [TestCase("bm3-10c.wti")]
        public void GivenWtiFileWhenDeserializingAndSerializingThenTheStringsAreEqual(string fileNameIn)
        {
            // Given WTI file
            string fullFileNameIn = Path.Combine(WtiFilesMap, fileNameIn);

            // When Deserializing and Serializing
            string xmlInput = File.ReadAllText(fullFileNameIn);
            string fileNameOut = fileNameIn + ".out";
            string fullFileNameOut = Path.Combine(WtiFilesMap, fileNameOut);
            KernelModel kernelModel = WtiDeserializer.Deserialize(xmlInput);
            string xmlOutput = WtiSerializer.Serialize(kernelModel);
            File.WriteAllText(fullFileNameOut, xmlOutput);

            // Then the strings are equal
            Assert.AreEqual(xmlInput, xmlOutput);
        }

        [Test]
        // [Category(Categories.WorkInProgress)] // The actual code has to be implemented
        public void GivenDamEngineDataModelWhenSerializingAndDeserializingTheDataModelsAreEqual()
        {
            // Given DamEngine data (DamProjectData)
            DamProjectData expectedDamProjectData = CreateExampleDamProjectData();
            Data.Geometry.Waternet expectedWaternet = CreateExampleWaternet();
            UpliftVanCalculationGrid expectedUpliftVanCalculationGrid = CreateExampleUpliftVanCalculationGrid();

            Location expectedLocation = expectedDamProjectData.Dike.Locations[0];
            SoilList expectedSoilList = expectedDamProjectData.Dike.SoilList;
            SoilProfile2D expectedSoilProfile2D = expectedLocation.Segment.SoilProfileProbabilities[0].SoilProfile2D;
            SurfaceLine2 expectedSurfaceLine2D = expectedLocation.SurfaceLine;
            FailureMechanismParametersMStab expectedParametersMStab = expectedDamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismParametersMStab;
            TrafficLoad expectedTrafficLoad = new TrafficLoad()
            {
                Pressure = 6.0,
                XStart = expectedSurfaceLine2D.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X,
                XEnd = expectedSurfaceLine2D.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X,

            };
            FillWtiKernelData fillWtiKernelData = new FillWtiKernelData()
            {
                SoilList = expectedSoilList,
                FailureMechanismParametersMStab = expectedParametersMStab,
                Location = expectedLocation,
                SoilProfile2D = expectedSoilProfile2D,
                SurfaceLine2 = expectedSurfaceLine2D,
                Waternet = expectedWaternet,
                UpliftVanCalculationGrid = expectedUpliftVanCalculationGrid,
                TrafficLoad = expectedTrafficLoad
            };
            KernelModel expectedKernelModel = fillWtiKernelData.CreateKernelModel();

            // When Serializing and Deserializing
            string xmlWti = WtiSerializer.Serialize(expectedKernelModel);
            const string fileName = "TestInput.wti";
            string fullFileName = Path.Combine(WtiFilesMap, fileName);
            File.WriteAllText(fullFileName, xmlWti);
            KernelModel actualKernelModel = WtiDeserializer.Deserialize(xmlWti);
            var fillDamEngineFromWti = new FillDamEngineFromWti();
            fillDamEngineFromWti.FillDamProjectDataFromKernelModel(actualKernelModel);

            // Then the data models are equal
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            ComparisonResult result;
            return;
            // TODO fix following comparisons. Can be done if all code is implemented
            result = compare.Compare(expectedSurfaceLine2D, fillDamEngineFromWti.SurfaceLine2);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SurfaceLine2");
            result = compare.Compare(expectedSoilProfile2D, fillDamEngineFromWti.SoilProfile2D);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilProfile2D");
            result = compare.Compare(expectedSoilList, fillDamEngineFromWti.SoilList);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilList");
            result = compare.Compare(expectedLocation, fillDamEngineFromWti.Location);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Location");
            result = compare.Compare(expectedParametersMStab, fillDamEngineFromWti.FailureMechanismParametersMStab);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel FailureMechanismParametersMStab");

        }

        private UpliftVanCalculationGrid CreateExampleUpliftVanCalculationGrid()
        {
            var upliftVanCalculationGrid = new UpliftVanCalculationGrid()
            {
                LeftGridXLeft = 1.1,
                LeftGridXRight = 2.1,
                LeftGridZTop = 3.1,
                LeftGridZBottom = 4.1,
                LeftGridXCount = 4,
                LeftGridZCount = 6,

                RightGridXLeft = 5.1,
                RightGridXRight = 6.1,
                RightGridZTop = 7.1,
                RightGridZBottom = 8.1,
                RightGridXCount = 5,
                RightGridZCount = 7,
            };
            return upliftVanCalculationGrid;
        }

        private Data.Geometry.Waternet CreateExampleWaternet()
        {
            var waterNet = new Data.Geometry.Waternet()
            {
                IsGenerated = false,
                UnitWeight = 9.81,
                Name = "Test Waternet",
            };
            var phreaticLine = new Data.Geometry.PhreaticLine()
            {
                Name = "Test Phreatic line"
            };
            waterNet.PhreaticLine = phreaticLine;
            var headLine = new HeadLine()
            {
                Name = "Test Head line"
            }; 
            waterNet.HeadLineList.Add(headLine);
            var waternetLine = new Data.Geometry.WaternetLine()
            {
                Name = "Test waternet line",
                HeadLine = headLine
            };
            waterNet.WaternetLineList.Add(waternetLine);
            return waterNet;
        }

        [TestCase("Benchmark 1-01b.wti")]
        [TestCase("bm3-10c.wti")]
        public void GivenWtiFileWhenFillingToDamEngineDataAndWritingBackToKernelDataThenTheKernelModelsAreEqual(string fileNameIn)
        {
            // Given Wti file
            string fullFileNameIn = Path.Combine(WtiFilesMap, fileNameIn);

            // When filling to DamEngine data 
            string xmlInput = File.ReadAllText(fullFileNameIn);
            KernelModel expectedKernelModel = WtiDeserializer.Deserialize(xmlInput);
            FillDamEngineFromWti fillDamEngineFromWti = new FillDamEngineFromWti();
            fillDamEngineFromWti.FillDamProjectDataFromKernelModel(expectedKernelModel);

            // And writing back to kernel data
            FillWtiKernelData fillWtiKernelData = new FillWtiKernelData()
            {
                SoilList = fillDamEngineFromWti.SoilList,
                Waternet = fillDamEngineFromWti.Waternet,
                FailureMechanismParametersMStab = fillDamEngineFromWti.FailureMechanismParametersMStab,
                Location = fillDamEngineFromWti.Location,
                SoilProfile2D = fillDamEngineFromWti.SoilProfile2D,
                SurfaceLine2 = fillDamEngineFromWti.SurfaceLine2,
                UpliftVanCalculationGrid = fillDamEngineFromWti.UpliftVanCalculationGrid,
                TrafficLoad = fillDamEngineFromWti.TrafficLoad
            };
            KernelModel actualKernelModel = fillWtiKernelData.CreateKernelModel();
            string xmlOutput = WtiSerializer.Serialize(actualKernelModel);
            string fileNameOut = fileNameIn + ".out";
            string fullFileNameOut = Path.Combine(WtiFilesMap, fileNameOut);
            File.WriteAllText(fullFileNameOut, xmlOutput);

            // Then the kernel models are equal
            CompareStabilityModel(expectedKernelModel.StabilityModel, actualKernelModel.StabilityModel);
            CompareSoilModel(expectedKernelModel.StabilityModel.SoilModel, actualKernelModel.StabilityModel.SoilModel);
            CompareSoilProfile2D(expectedKernelModel.StabilityModel.SoilProfile, actualKernelModel.StabilityModel.SoilProfile);
            CompareSoilSurfaceLine(expectedKernelModel.PreprocessingModel.LastStage.SurfaceLine.CharacteristicPoints, 
                actualKernelModel.PreprocessingModel.LastStage.SurfaceLine.CharacteristicPoints);
            CompareWaternet(expectedKernelModel.StabilityModel.LastStage.GeotechnicsData.CurrentWaternet, 
                actualKernelModel.StabilityModel.LastStage.GeotechnicsData.CurrentWaternet);
            CompareUpliftVanCalculationGrid(expectedKernelModel.StabilityModel.SlipPlaneUpliftVan, actualKernelModel.StabilityModel.SlipPlaneUpliftVan);
            CompareTrafficLoad(expectedKernelModel.StabilityModel.LastStage.UniformLoads, actualKernelModel.StabilityModel.LastStage.UniformLoads);
        }

        private void CompareTrafficLoad(List<UniformLoad> expectedUniformLoads, List<Deltares.SoilStress.Data.UniformLoad> actualUniformLoads)
        {
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToInclude = new List<string>()
            {
                "XEnd", 
                "XStart",
                "Pressure"
            };
            ComparisonResult result;
            result = compare.Compare(expectedUniformLoads, actualUniformLoads);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Traffic Load");
        }

        private void CompareUpliftVanCalculationGrid(SlipPlaneUpliftVan expectedSlipPlaneUpliftVan, SlipPlaneUpliftVan actualSlipPlaneUpliftVan)
        {
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToIgnore = new List<string>()
            {
                "TangentLinesBoundaries", // Needed to avoid exception in comparison
                "TangentLineXLeft", // not relevant
                "TangentLineXRight", // not relevant
                "MoveGrid" // not relevant
            };
            ComparisonResult result;
            result = compare.Compare(expectedSlipPlaneUpliftVan.SlipPlaneTangentLine, actualSlipPlaneUpliftVan.SlipPlaneTangentLine);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel UpliftVanCalculationGrid Tangent Lines");
            result = compare.Compare(expectedSlipPlaneUpliftVan.SlipPlaneRightGrid, actualSlipPlaneUpliftVan.SlipPlaneRightGrid);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel UpliftVanCalculationGrid Right grid");
            result = compare.Compare(expectedSlipPlaneUpliftVan.SlipPlaneLeftGrid, actualSlipPlaneUpliftVan.SlipPlaneLeftGrid);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel UpliftVanCalculationGrid Left grid");
        }

        private void CompareWaternet(Waternet expectedWaternet, Waternet actualWaternet)
        {
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToIgnore = new List<string>()
            {
                "Waternet",
                "Owner"
            };
            ComparisonResult result;
            Assert.AreEqual(expectedWaternet.IsGenerated, actualWaternet.IsGenerated);
            Assert.AreEqual(expectedWaternet.UnitWeight, actualWaternet.UnitWeight);
            result = compare.Compare(expectedWaternet.PhreaticLine, actualWaternet.PhreaticLine);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.PhreaticLine");
            result = compare.Compare(expectedWaternet.WaternetLineList, actualWaternet.WaternetLineList);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.WaternetLineList");
            result = compare.Compare(expectedWaternet.HeadLineList, actualWaternet.HeadLineList);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Waternet.HeadLineList");
            Assert.AreEqual(expectedWaternet.ExternalWaterLevel, actualWaternet.ExternalWaterLevel);
        }

        private void CompareSoilSurfaceLine(CharacteristicPointSet expectedCharacteristicPoints, CharacteristicPointSet actualCharacteristicPoints)
        {
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToIgnore = new List<string>()
            {
                "Owner"
            };
            var result = compare.Compare(expectedCharacteristicPoints, actualCharacteristicPoints);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SurfaceLine");
        }

        private void CompareSoilProfile2D(MacroStability.Geometry.SoilProfile2D expectedSoilProfile, MacroStability.Geometry.SoilProfile2D actualSoilProfile)
        {
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToIgnore = SoilParametersToIgnore;
            var result = compare.Compare(expectedSoilProfile, actualSoilProfile);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilProfile2D");
        }


        private void CompareSoilModel(SoilModel expectedSoilModel, SoilModel actualSoilModel)
        {
            Assert.AreEqual(expectedSoilModel.Soils.Count, actualSoilModel.Soils.Count, "Soil Count does not match");
            foreach (Soil expectedSoil in expectedSoilModel.Soils)
            {
                var actualSoil = actualSoilModel.Soils.First(soil => soil.Name.Equals(expectedSoil.Name));
                Assert.IsNotNull(actualSoil, string.Format("Soil {0} not found", expectedSoil.Name));
                var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
                compare.Config.MembersToIgnore = SoilParametersToIgnore;
                var result = compare.Compare(expectedSoil, actualSoil);
                Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilModel");
            }
        }

        private void CompareStabilityModel(StabilityModel expectedStabilityModel, StabilityModel actualStabilityModel)
        {
            Assert.AreEqual(expectedStabilityModel.SearchAlgorithm, actualStabilityModel.SearchAlgorithm);
            Assert.AreEqual(expectedStabilityModel.ModelOption, actualStabilityModel.ModelOption);
            Assert.AreEqual(expectedStabilityModel.GridOrientation, actualStabilityModel.GridOrientation);
        }

        [TestCase("ValidateOk.xml")]
        [TestCase("ValidateError.xml")]
        public void GivenValidationResultFileWhenDeserializingAndSerializingThenTheStringsAreEqual(string fileNameIn)
        {
            // Given validation result file from kernel
            string fullFileNameIn = Path.Combine(WtiFilesMap, fileNameIn);

            // When Deserializing and Serializing
            string xmlInput = File.ReadAllText(fullFileNameIn);
            string fileNameOut = fileNameIn + ".out";
            string fullFileNameOut = Path.Combine(WtiFilesMap, fileNameOut);
            IValidationResult[] validationResults = WtiDeserializer.DeserializeValidation(xmlInput);
            string xmlOutput = WtiSerializer.SerializeValidation(validationResults);
            File.WriteAllText(fullFileNameOut, xmlOutput);

            // Then the strings are equal
            Assert.AreEqual(xmlInput, xmlOutput);
        }

        [TestCase("Result1.xml")]
        public void GivenCalculationResultFileWhenDeserializingAndSerializingThenTheStringsAreEqual(string fileNameIn)
        {
            // Given calculation result file from kernel
            string fullFileNameIn = Path.Combine(WtiFilesMap, fileNameIn);

            // When Deserializing and Serializing
            string xmlInput = File.ReadAllText(fullFileNameIn);
            string fileNameOut = fileNameIn + ".out";
            string fullFileNameOut = Path.Combine(WtiFilesMap, fileNameOut);
            var calculationResults = WtiDeserializer.DeserializeResult(xmlInput);
            string xmlOutput = WtiSerializer.SerializeResult(calculationResults);
            File.WriteAllText(fullFileNameOut, xmlOutput);

            // Then the strings are equal
            Assert.AreEqual(xmlInput, xmlOutput);
        }
        private DamProjectData CreateExampleDamProjectData()
        {
            return FactoryForDamProjectData.CreateExampleDamProjectData();
        }

    }
}