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

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon
{
    [TestFixture]
    public class ConversionHelperTests
    {
        #region SearchMethod
        [Test]
        [TestCase(SearchAlgorithm.Grid, MStabSearchMethod.Grid)]
        [TestCase(SearchAlgorithm.Genetic, MStabSearchMethod.GeneticAlgorithm)]
        public void CanConvertToDamSearchMethod(SearchAlgorithm searchAlgorithm, MStabSearchMethod mStabSearchMethod)
        {
            Assert.AreEqual(mStabSearchMethod, ConversionHelper.ConvertToDamSearchMethod(searchAlgorithm));
        }

        [ExpectedException(typeof(ArgumentException))]
        [TestCase(SearchAlgorithm.Beeswarm)]
        [TestCase(SearchAlgorithm.LevenbergMarquardt)]
        [TestCase(SearchAlgorithm.Single)]
        public void CanConvertToDamSearchMethodHandleException(SearchAlgorithm searchAlgorithm)
        {
            ConversionHelper.ConvertToDamSearchMethod(searchAlgorithm);
        }

        [Test]
        [TestCase(MStabSearchMethod.Grid, SearchAlgorithm.Grid)]
        [TestCase(MStabSearchMethod.GeneticAlgorithm, SearchAlgorithm.Genetic)]
        public void ConvertToMacroStabilitySearchMethod(MStabSearchMethod mStabSearchMethod, SearchAlgorithm searchAlgorithm)
        {
            Assert.AreEqual(searchAlgorithm, ConversionHelper.ConvertToMacroStabilitySearchMethod(mStabSearchMethod));
        }

        #endregion

        #region ModelType
        [Test]
        [TestCase(ModelOptions.Bishop, MStabModelType.Bishop)]
        [TestCase(ModelOptions.BishopProbabilityRandomField, MStabModelType.BishopRandomField)]
        [TestCase(ModelOptions.Fellenius, MStabModelType.Fellenius)]
        [TestCase(ModelOptions.HorizontalBalance, MStabModelType.HorizontalBalance)]
        [TestCase(ModelOptions.Spencer, MStabModelType.Spencer)]
        [TestCase(ModelOptions.UpliftSpencer, MStabModelType.UpliftSpencer)]
        [TestCase(ModelOptions.UpliftVan, MStabModelType.UpliftVan)]
        public void CanConvertToMStabModelType(ModelOptions modelOption, MStabModelType mStabModelType)
        {
            Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(modelOption));
        }

        [Test]
        [TestCase(MStabModelType.Bishop, ModelOptions.Bishop)]
        [TestCase(MStabModelType.BishopRandomField, ModelOptions.BishopProbabilityRandomField)]
        [TestCase(MStabModelType.Fellenius, ModelOptions.Fellenius)]
        [TestCase(MStabModelType.HorizontalBalance, ModelOptions.HorizontalBalance)]
        [TestCase(MStabModelType.Spencer, ModelOptions.Spencer)]
        [TestCase(MStabModelType.UpliftSpencer, ModelOptions.UpliftSpencer)]
        [TestCase(MStabModelType.UpliftVan, ModelOptions.UpliftVan)]
        public void CanConvertToModelOptions(MStabModelType mStabModelType, ModelOptions modelOption)
        {
            Assert.AreEqual(modelOption, ConversionHelper.ConvertToModelOptions(mStabModelType));
        }

        [ExpectedException(typeof(ArgumentException))]
        [TestCase(MStabModelType.SpencerLow)]
        [TestCase(MStabModelType.SpencerHigh)]
        public void CanConvertToModelOptionsHandleException(MStabModelType mStabModelType)
        {
            ConversionHelper.ConvertToModelOptions(mStabModelType);
        }

        #endregion

        #region GridOrientation
        [TestCase(GridOrientation.Outwards, MStabGridPosition.Left)]
        [TestCase(GridOrientation.Inwards, MStabGridPosition.Right)]
        public static void CanConvertToMStabGridPosition(GridOrientation gridOrientation, MStabGridPosition mStabGridPosition)
        {
            Assert.AreEqual(mStabGridPosition, ConversionHelper.ConvertToMStabGridPosition(gridOrientation));
        }
        [TestCase(MStabGridPosition.Left, GridOrientation.Outwards)]
        [TestCase(MStabGridPosition.Right, GridOrientation.Inwards)]
        public static void CanConvertToGridOrientation(MStabGridPosition mStabGridPosition, GridOrientation gridOrientation)
        {
            Assert.AreEqual(gridOrientation, ConversionHelper.ConvertToGridOrientation(mStabGridPosition));
        }
        #endregion

        #region Soil
        [Test]
        [Category(Categories.WorkInProgress)]
        public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal()
        {
            // Given MacroStability Soil
            var macroStabilitySoil = new MacroStability.Geometry.Soil()
            {
                Name = "MacroStabilitySoil",
                AbovePhreaticLevel = 1.01,
                BelowPhreaticLevel = 1.02,
                Cohesion = 1.03,
                FrictionAngle = 1.04,
                Dilatancy = -1.045, // -Phi (FrictionAngle)
                RRatio = 1.05,
                RatioCuPc  = 1.06,
                RheologicalCoefficient = 1.07,
                StrengthIncreaseExponent = 1.08,
                UseSoilType = true,
                BondStressCurve = null
            };

            // When Converting to DamSoil and back
            Soil damSoil = ConversionHelper.ConvertToDamSoil(macroStabilitySoil);
            var actualMacroStabilitySoil = ConversionHelper.ConvertToMacroStabilitySoil(damSoil);

            // Then result equals original
            var compare = new CompareLogic { Config = { MaxDifferences = 100 } };
            var result = compare.Compare(macroStabilitySoil, actualMacroStabilitySoil);
            Assert.AreEqual(0, result.Differences.Count, "Differences found converting/reconverting Soil");
        }
        #endregion

        #region WaterpressureInterpolationModel
        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Automatic, WaterpressureInterpolationModel.Automatic)]
        [TestCase(Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic, WaterpressureInterpolationModel.Hydrostatic)]
        public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
            Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel, WaterpressureInterpolationModel waterpressureInterpolationModel)
        {
            Assert.AreEqual(waterpressureInterpolationModel, ConversionHelper.ConvertToMacroStabilityWaterpressureInterpolationModel(damWaterpressureInterpolationModel));
        }

        [TestCase(WaterpressureInterpolationModel.Automatic, Data.Geotechnics.WaterpressureInterpolationModel.Automatic)]
        [TestCase(WaterpressureInterpolationModel.Hydrostatic, Data.Geotechnics.WaterpressureInterpolationModel.Hydrostatic)]
        public static void CanConvertToDamWaterpressureInterpolationModel(
            WaterpressureInterpolationModel waterpressureInterpolationModel, Data.Geotechnics.WaterpressureInterpolationModel damWaterpressureInterpolationModel)
        {
            Assert.AreEqual(damWaterpressureInterpolationModel, ConversionHelper.ConvertToDamWaterpressureInterpolationModel(waterpressureInterpolationModel));
        }
        #endregion

    }
}