// 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 NUnit.Framework;
using Deltares.MacroStability.Kernel;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.TestHelpers;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.TestHelpers.Factories;
using Deltares.MacroStability.Data;
using Deltares.MacroStability.Standard;
using KellermanSoftware.CompareNetObjects;

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

        [TestCase("Benchmark 1-01b.wti")]
        [TestCase("Benchmark 2-04a.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)]
        public void GivenDamEngineDataModelWhenSerializingAndDeserializingTheDataModelsAreEqual()
        {
            // Given DamEngine data (DamProjectData)
            DamProjectData expectedDamProjectData = CreateExampleDamProjectData();

            Location expectedLocation = expectedDamProjectData.Dike.Locations[0];
            SoilProfile2D expectedSoilProfile2D = expectedLocation.Segment.SoilProfileProbabilities[0].SoilProfile2D;
            SurfaceLine2 expectedSurfaceLine2D = expectedLocation.SurfaceLine;
            FailureMechanismParametersMStab expectedParametersMStab = expectedDamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismParametersMStab;
            FillWtiKernelData fillWtiKernelData = new FillWtiKernelData()
            {
                FailureMechanismParametersMStab = expectedParametersMStab,
                Location = expectedLocation,
                SoilProfile2D = expectedSoilProfile2D,
                SurfaceLine2 = expectedSurfaceLine2D
            };
            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 } };
            var result = compare.Compare(expectedLocation, fillDamEngineFromWti.Location);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel Location");
            result = compare.Compare(expectedSoilProfile2D, fillDamEngineFromWti.SoilProfile2D);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilProfile2D");
            result = compare.Compare(expectedSurfaceLine2D, fillDamEngineFromWti.SurfaceLine2);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SurfaceLine2");
            result = compare.Compare(expectedParametersMStab, fillDamEngineFromWti.FailureMechanismParametersMStab);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel FailureMechanismParametersMStab");

        }

        [TestCase("Benchmark 1-01b.wti")]
        [TestCase("Benchmark 2-04a.wti")]
        //[Category(Categories.WorkInProgress)]
        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()
            {
                FailureMechanismParametersMStab = fillDamEngineFromWti.FailureMechanismParametersMStab,
                Location = fillDamEngineFromWti.Location,
                SoilProfile2D = fillDamEngineFromWti.SoilProfile2D,
                SurfaceLine2 = fillDamEngineFromWti.SurfaceLine2
            };
            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);
            return;

            //Enable asserts when code is implemented
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            compare.Config.MembersToIgnore = new List<string>
            {
            };
            var result = compare.Compare(expectedKernelModel.StabilityModel.SoilModel, actualKernelModel.StabilityModel.SoilModel);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilModel");
            result = compare.Compare(expectedKernelModel.StabilityModel.SoilProfile, actualKernelModel.StabilityModel.SoilProfile);
            Assert.AreEqual(0, result.Differences.Count, "Differences found read/write kernel SoilProfile");
        }

        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();
        }

    }
}