// 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.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.MacroStability.CSharpWrapper.Input;
using Deltares.MacroStability.CSharpWrapper.Output;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using CharacteristicPoint = Deltares.MacroStability.CSharpWrapper.Input.CharacteristicPointType;
using CharacteristicPointType = Deltares.DamEngine.Data.Geotechnics.CharacteristicPointType;
using ConversionHelper = Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon.MacroStabilityIo.ConversionHelper;
using LogMessageType = Deltares.DamEngine.Data.Standard.Logging.LogMessageType;
using ShearStrengthModel = Deltares.DamEngine.Data.Geotechnics.ShearStrengthModel;
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(StabilityModelOption.Bishop, MStabModelType.BishopWti)]
        [TestCase(StabilityModelOptionType.UpliftVan, MStabModelType.UpliftVan)]
        public void CanConvertToMStabModelType(StabilityModelOptionType modelOption, MStabModelType mStabModelType)
        {
            Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(modelOption));
        }

        [Test]
        [TestCase(StabilityModelOptionType.Bishop, MStabModelType.BishopWti)]
        [TestCase(StabilityModelOptionType.UpliftVan, MStabModelType.UpliftVan)]
        public void CanConvertToMStabModelTypeFromOutput(StabilityModelOptionType modelOption, MStabModelType mStabModelType)
        {
            Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelTypeFromOutput(modelOption));
        }

        [Test]
        [TestCase(MStabModelType.UpliftVan, StabilityModelOptionType.UpliftVan)]
        public void CanConvertToModelOptions(MStabModelType mStabModelType, StabilityModelOptionType modelOption)
        {
            Assert.AreEqual(modelOption, ConversionHelper.ConvertToModelOptions(mStabModelType));
        }

        [Test]
        [TestCase(MStabModelType.UpliftVan, StabilityModelOptionType.UpliftVan)]
        public void CanConvertToModelOptionsOutput(MStabModelType mStabModelType, StabilityModelOptionType modelOption)
        {
            Assert.AreEqual(modelOption, ConversionHelper.ConvertToModelOptionsOutput(mStabModelType));
        }

        [ExpectedException(typeof(ArgumentException))]
        [TestCase(MStabModelType.Bishop)]
        [TestCase(MStabModelType.UpliftSpencer)]
        [TestCase(MStabModelType.SpencerLow)]
        [TestCase(MStabModelType.SpencerHigh)]
        [TestCase(MStabModelType.BishopUpliftVan)]
        [TestCase(MStabModelType.BishopRandomField)]
        [TestCase(MStabModelType.Fellenius)]
        [TestCase(MStabModelType.BishopWti)]
        [TestCase(MStabModelType.HorizontalBalance)]
        [TestCase(MStabModelType.Spencer)]
        [TestCase(MStabModelType.UpliftSpencerWti)]
        public void CanConvertToModelOptionsHandleException(MStabModelType mStabModelType)
        {
            ConversionHelper.ConvertToModelOptions(mStabModelType);
        }

        [ExpectedException(typeof(ArgumentException))]
        [TestCase(MStabModelType.Bishop)]
        [TestCase(MStabModelType.UpliftSpencer)]
        [TestCase(MStabModelType.SpencerLow)]
        [TestCase(MStabModelType.SpencerHigh)]
        [TestCase(MStabModelType.BishopUpliftVan)]
        [TestCase(MStabModelType.BishopRandomField)]
        [TestCase(MStabModelType.Fellenius)]
        [TestCase(MStabModelType.BishopWti)]
        [TestCase(MStabModelType.HorizontalBalance)]
        [TestCase(MStabModelType.Spencer)]
        [TestCase(MStabModelType.UpliftSpencerWti)]
        public void CanConvertToModelOptionsOutputHandleException(MStabModelType mStabModelType)
        {
            ConversionHelper.ConvertToModelOptionsOutput(mStabModelType);
        }
        #endregion

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

        #region Soil
        [TestCase(DilatancyType.MinusPhi)]
        [TestCase(DilatancyType.Phi)]
        [TestCase(DilatancyType.Zero)]
        public void GivenMacroStabilitySoilWhenConvertingToDamSoilAndBackThenResultEqualsOriginal(DilatancyType dilatancyType)
        {
            // Given MacroStability Soil
            var macroStabilitySoil = new MacroStability.CSharpWrapper.Input.Soil()
            {
                Name = "MacroStabilitySoil",
                AbovePhreaticLevel = 1.01,
                BelowPhreaticLevel = 1.02,
                Cohesion = 1.03,
                FrictionAngle = 1.04,
                Dilatancy = 0,
                RRatio = 1.05,
                RatioCuPc = 1.06,
                ShearStrengthAbovePhreaticLevelModel = MacroStability.CSharpWrapper.ShearStrengthModelType.MohrCoulomb,
                ShearStrengthBelowPhreaticLevelModel = MacroStability.CSharpWrapper.ShearStrengthModelType.MohrCoulomb,
                //RheologicalCoefficient = 1.07, Not yet to be used
                StrengthIncreaseExponent = 1.08,
                UseSoilClassification = false, // must be false
                BondStressCurve = null // must be null
            };
            switch (dilatancyType)
            {
                case DilatancyType.MinusPhi:
                {
                    macroStabilitySoil.Dilatancy = macroStabilitySoil.FrictionAngle * -1;
                    break;
                }
                case DilatancyType.Phi:
                {
                    macroStabilitySoil.Dilatancy = macroStabilitySoil.FrictionAngle;
                    break;
                }
                case DilatancyType.Zero:
                {
                    macroStabilitySoil.Dilatancy = 0;
                    break;
                }

            }

            // 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 but this ok now if diff = 3");
        }

        #endregion

        #region ShearStrengthModel
        [TestCase(MacroStability.CSharpWrapper.ShearStrengthModelType.MohrCoulomb, ShearStrengthModel.CPhi)]
        [TestCase(MacroStability.CSharpWrapper.ShearStrengthModelType.Shansep, ShearStrengthModel.SuCalculated)]
        public static void CanConvertToDamShearStrengthModel(
            MacroStability.CSharpWrapper.ShearStrengthModelType kernelShearStrengthModel, ShearStrengthModel damShearStrengthModel)
        {
            Assert.AreEqual(damShearStrengthModel, ConversionHelper.ConvertToDamShearStrengthModel(kernelShearStrengthModel));
        }

        [TestCase(ShearStrengthModel.CPhi, MacroStability.CSharpWrapper.ShearStrengthModelType.MohrCoulomb)]
        [TestCase(ShearStrengthModel.SuCalculated, MacroStability.CSharpWrapper.ShearStrengthModelType.Shansep)]
        public static void CanConvertToMacroStabilityShearStrengthModel(
            ShearStrengthModel damShearStrengthModel, MacroStability.CSharpWrapper.ShearStrengthModelType kernelShearStrengthModel)
        {
            Assert.AreEqual(kernelShearStrengthModel, ConversionHelper.ConvertToMacroStabilityShearStrengthModel(damShearStrengthModel));
        }
        #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

        #region CharacteristicPointType
        [TestCase(CharacteristicPointType.BottomDitchPolderSide, CharacteristicPoint.BottomDitchPolderSide)]
        [TestCase(CharacteristicPointType.BottomDitchDikeSide, CharacteristicPoint.BottomDitchDikeSide)]
        //[TestCase(CharacteristicPointType.DikeLine, CharacteristicPoint.DikeLine)]
        [TestCase(CharacteristicPointType.DikeToeAtPolder, CharacteristicPoint.DikeToeAtPolder)]
        [TestCase(CharacteristicPointType.DikeToeAtRiver, CharacteristicPoint.DikeToeAtRiver)]
        [TestCase(CharacteristicPointType.DikeTopAtPolder, CharacteristicPoint.DikeTopAtPolder)]
        [TestCase(CharacteristicPointType.DikeTopAtRiver, CharacteristicPoint.DikeTopAtRiver)]
        [TestCase(CharacteristicPointType.DitchDikeSide, CharacteristicPoint.DitchDikeSide)]
        [TestCase(CharacteristicPointType.DitchPolderSide, CharacteristicPoint.DitchPolderSide)]
        [TestCase(CharacteristicPointType.None, CharacteristicPoint.None)]
        [TestCase(CharacteristicPointType.ShoulderBaseInside, CharacteristicPoint.ShoulderBaseInside)]
        [TestCase(CharacteristicPointType.ShoulderBaseOutside, CharacteristicPoint.ShoulderBaseOutside)]
        [TestCase(CharacteristicPointType.ShoulderTopInside, CharacteristicPoint.ShoulderTopInside)]
        [TestCase(CharacteristicPointType.ShoulderTopOutside, CharacteristicPoint.ShoulderTopOutside)]
        [TestCase(CharacteristicPointType.SurfaceLevelInside, CharacteristicPoint.SurfaceLevelInside)]
        [TestCase(CharacteristicPointType.SurfaceLevelOutside, CharacteristicPoint.SurfaceLevelOutside)]
        [TestCase(CharacteristicPointType.TrafficLoadInside, CharacteristicPoint.TrafficLoadInside)]
        [TestCase(CharacteristicPointType.TrafficLoadOutside, CharacteristicPoint.TrafficLoadOutside)]
        public static void CanConvertToMacroStabilityWaterpressureInterpolationModel(
            CharacteristicPointType damCharacteristicPointType, CharacteristicPoint kernelCharacteristicPointType)
        {
            Assert.AreEqual(kernelCharacteristicPointType, ConversionHelper.ConvertToMacroStabilityCharacteristicPointType(damCharacteristicPointType));
        }

        [TestCase(CharacteristicPoint.BottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
        [TestCase(CharacteristicPoint.BottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
       // [TestCase(CharacteristicPoint.DikeLine, CharacteristicPointType.DikeLine)]
        [TestCase(CharacteristicPoint.DikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
        [TestCase(CharacteristicPoint.DikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
        [TestCase(CharacteristicPoint.DikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
        [TestCase(CharacteristicPoint.DikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
        [TestCase(CharacteristicPoint.DitchDikeSide, CharacteristicPointType.DitchDikeSide)]
        [TestCase(CharacteristicPoint.DitchPolderSide, CharacteristicPointType.DitchPolderSide)]
        [TestCase(CharacteristicPoint.None, CharacteristicPointType.None)]
        [TestCase(CharacteristicPoint.ShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
        [TestCase(CharacteristicPoint.ShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
        [TestCase(CharacteristicPoint.ShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
        [TestCase(CharacteristicPoint.ShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
        [TestCase(CharacteristicPoint.SurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
        [TestCase(CharacteristicPoint.SurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
        [TestCase(CharacteristicPoint.TrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
        [TestCase(CharacteristicPoint.TrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
        public static void CanConvertToDamWaterpressureInterpolationModel(
            CharacteristicPoint kernelCharacteristicPointType, CharacteristicPointType damCharacteristicPointType)
        {
            Assert.AreEqual(damCharacteristicPointType, ConversionHelper.ConvertToDamCharacteristicPointType(kernelCharacteristicPointType));
        }
        #endregion

        #region LogMessages
        [TestCase(LogMessageType.Info, MessageType.Info)]
        [TestCase(LogMessageType.Warning, MessageType.Warning)]
        [TestCase(LogMessageType.Error, MessageType.Error)]
        public void CanConvertLogMessageTypeToKernelLogMessageType(LogMessageType logMessageType, MessageType messageType)
        {
            Assert.AreEqual(messageType,
                ConversionHelper.ConvertLogMessageTypeToKernelLogMessageType(logMessageType));
        }

        [TestCase(MessageType.Info, LogMessageType.Info)]
        [TestCase(MessageType.Warning, LogMessageType.Warning)]
        [TestCase(MessageType.Error, LogMessageType.Error)]
        public void CanConvertKernelLogMessageTypeToLogMessageType(MessageType kernelLogMessageType,
            LogMessageType logMessageType)
        {
            Assert.AreEqual(logMessageType,
                ConversionHelper.ConvertKernelLogMessageTypeToLogMessageType(kernelLogMessageType));
        }
        #endregion

        [TestCase(CalculationResult.NoInput, CalculationResultType.NoInput)]
        [TestCase(CalculationResult.NoRun, CalculationResultType.NoRun)]
        [TestCase(CalculationResult.Succeeded, CalculationResultType.Succeeded)]
        [TestCase(CalculationResult.InvalidInputData, CalculationResultType.InvalidInputData)]
        [TestCase(CalculationResult.InvalidInputStructure, CalculationResultType.InvalidInputStructure)]
        [TestCase(CalculationResult.NoLicense, CalculationResultType.NoLicense)]
        [TestCase(CalculationResult.RunFailed, CalculationResultType.RunFailed)]
        [TestCase(CalculationResult.UnexpectedError, CalculationResultType.UnexpectedError)]
        [TestCase(CalculationResult.UserAbort, CalculationResultType.UserAbort)]
        public void CanConvertToMacroStabilityResultType(CalculationResult calculationResult, CalculationResultType calculationResultType)
        {
            Assert.AreEqual(calculationResultType, ConversionHelper.ConvertToMacroStabilityResultType(calculationResult));
        }

        [TestCase(CalculationResultType.NoInput, CalculationResult.NoInput)]
        [TestCase(CalculationResultType.NoRun, CalculationResult.NoRun)]
        [TestCase(CalculationResultType.Succeeded, CalculationResult.Succeeded)]
        [TestCase(CalculationResultType.InvalidInputData, CalculationResult.InvalidInputData)]
        [TestCase(CalculationResultType.InvalidInputStructure, CalculationResult.InvalidInputStructure)]
        [TestCase(CalculationResultType.NoLicense, CalculationResult.NoLicense)]
        [TestCase(CalculationResultType.RunFailed, CalculationResult.RunFailed)]
        [TestCase(CalculationResultType.UnexpectedError, CalculationResult.UnexpectedError)]
        [TestCase(CalculationResultType.UserAbort, CalculationResult.UserAbort)]
        public void CanConvertToDamResultType(CalculationResultType calculationResultType, CalculationResult calculationResult)
        {
            Assert.AreEqual(calculationResult, ConversionHelper.ConvertToDamResultType(calculationResultType));
        }
    }
}