// Copyright (C) Stichting Deltares 2017. 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 Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.DamEngine.Io.XmlOutput;
using NUnit.Framework;

namespace Deltares.DamEngine.Interface.Tests
{
	[TestFixture]
    public class ConversionHelperTests
    {
		[Test]
        [TestCase(InputDamProjectType.Assessment, DamProjectType.Assessment)]
        [TestCase(InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional)]
        [TestCase(InputDamProjectType.Design, DamProjectType.Design)]
        [TestCase(InputDamProjectType.Operational, DamProjectType.Operational)]
        public void CanConvertToDamProjectType(InputDamProjectType inputDamProjectType, DamProjectType damProjectType)
        {
            Assert.AreEqual(damProjectType, ConversionHelper.ConvertToDamProjectType(inputDamProjectType));
        }

        [Test]
        [TestCase(DamProjectType.Assessment, InputDamProjectType.Assessment)]
        [TestCase(DamProjectType.AssessmentRegional, InputDamProjectType.AssessmentRegional)]
        [TestCase(DamProjectType.Design, InputDamProjectType.Design)]
        [TestCase(DamProjectType.Operational, InputDamProjectType.Operational)]
        public void CanConvertToInputDamProjectType(DamProjectType damProjectType, InputDamProjectType inputDamProjectType)
        {
            Assert.AreEqual(inputDamProjectType, ConversionHelper.ConvertToInputDamProjectType(damProjectType));
        }

        [Test]
        [TestCase(PLLineCreationMethod.ExpertKnowledgeLinearInDike, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike)]
        [TestCase(PLLineCreationMethod.ExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD)]
        [TestCase(PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD)]
        [TestCase(PLLineCreationMethod.None, LocationWaternetOptionsPhreaticLineCreationMethod.None)]
        [TestCase(PLLineCreationMethod.Sensors, LocationWaternetOptionsPhreaticLineCreationMethod.Sensors)]
        public void CanConvertToPlLineCreationMethod(PLLineCreationMethod plLineCreationMethod, LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod)
        {
            Assert.AreEqual(inputPhreaticLineCreationMethod, ConversionHelper.ConvertToInputPhreaticLineCreationMethod(plLineCreationMethod));
        }

        [Test]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike, PLLineCreationMethod.ExpertKnowledgeLinearInDike)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD, PLLineCreationMethod.ExpertKnowledgeRRD)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.None, PLLineCreationMethod.None)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.Sensors, PLLineCreationMethod.Sensors)]
        public void CanConvertToInputPlLineCreationMethod(LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod, PLLineCreationMethod plLineCreationMethod)
        {
            Assert.AreEqual(plLineCreationMethod, ConversionHelper.ConvertToPhreaticLineCreationMethod(inputPhreaticLineCreationMethod));
        }

        [Test]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic, IntrusionVerticalWaterPressureType.FullHydroStatic)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic, IntrusionVerticalWaterPressureType.HydroStatic)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear, IntrusionVerticalWaterPressureType.Linear)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent, IntrusionVerticalWaterPressureType.SemiTimeDependent)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard, IntrusionVerticalWaterPressureType.Standard)]
        public void CanConvertToIntrusionVerticalWaterPressureType(LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressureType, IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType)
        {
            Assert.AreEqual(intrusionVerticalWaterPressureType, ConversionHelper.ConvertToIntrusionVerticalWaterPressure(inputIntrusionVerticalWaterPressureType));
        }

        [Test]
        [TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic)]
        [TestCase(IntrusionVerticalWaterPressureType.HydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic)]
        [TestCase(IntrusionVerticalWaterPressureType.Linear, LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear)]
        [TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent)]
        [TestCase(IntrusionVerticalWaterPressureType.Standard, LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard)]
        public void CanConvertToInputIntrusionVerticalWaterPressureType(IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType, LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressureType)
        {
            Assert.AreEqual(inputIntrusionVerticalWaterPressureType, ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(intrusionVerticalWaterPressureType));
        }

        [Test]
        [TestCase(0, CalculationResult.NoRun)]
        [TestCase(1, CalculationResult.Succeeded)]
        [TestCase(2, CalculationResult.NoInput)]
        [TestCase(3, CalculationResult.NoLicense)]
        [TestCase(4, CalculationResult.UserAbort)]
        [TestCase(5, CalculationResult.InvalidInputStructure)]
        [TestCase(6, CalculationResult.InvalidInputData)]
        [TestCase(7, CalculationResult.RunFailed)]
        [TestCase(8, CalculationResult.UnexpectedError)]
        public void CanConvertToOutputCalculationResult(int result, CalculationResult calculationResult)
        {
            Assert.AreEqual(result, ConversionHelper.ConvertToOutputCalculationResult(calculationResult));
        }

        [Test]
        [TestCase(CalculationResult.NoRun, 0)]
        [TestCase(CalculationResult.Succeeded, 1)]
        [TestCase(CalculationResult.NoInput, 2)]
        [TestCase(CalculationResult.NoLicense, 3)]
        [TestCase(CalculationResult.UserAbort, 4)]
        [TestCase(CalculationResult.InvalidInputStructure, 5)]
        [TestCase(CalculationResult.InvalidInputData, 6)]
        [TestCase(CalculationResult.RunFailed, 7)]
        [TestCase(CalculationResult.UnexpectedError, 8)]
        public void CanConvertToCalculationResult(CalculationResult result, int calculationResult)
        {
            Assert.AreEqual(result, ConversionHelper.ConvertToCalculationResult(calculationResult));

        }

        [Test]
        [TestCase(ConversionHelper.CpNone, CharacteristicPointType.None)]
        [TestCase(ConversionHelper.CpSurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
        [TestCase(ConversionHelper.CpDikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
        [TestCase(ConversionHelper.CpShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
        [TestCase(ConversionHelper.CpShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
        [TestCase(ConversionHelper.CpDikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
        [TestCase(ConversionHelper.CpDikeLine, CharacteristicPointType.DikeLine)]
        [TestCase(ConversionHelper.CpTrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
        [TestCase(ConversionHelper.CpTrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
        [TestCase(ConversionHelper.CpDikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
        [TestCase(ConversionHelper.CpShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
        [TestCase(ConversionHelper.CpShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
        [TestCase(ConversionHelper.CpDikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
        [TestCase(ConversionHelper.CpDitchDikeSide, CharacteristicPointType.DitchDikeSide)]
        [TestCase(ConversionHelper.CpBottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
        [TestCase(ConversionHelper.CpBottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
        [TestCase(ConversionHelper.CpDitchPolderSide, CharacteristicPointType.DitchPolderSide)]
        [TestCase(ConversionHelper.CpSurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
        public void CanConvertToCharacteristicPointType(int inputPointType, CharacteristicPointType characteristicPointType)
        {
            Assert.AreEqual(characteristicPointType, ConversionHelper.ConvertToDamPointType(inputPointType));
        }
        [Test]
        [TestCase(CharacteristicPointType.None, ConversionHelper.CpNone)]
        [TestCase(CharacteristicPointType.SurfaceLevelOutside, ConversionHelper.CpSurfaceLevelOutside)]
        [TestCase(CharacteristicPointType.DikeToeAtRiver, ConversionHelper.CpDikeToeAtRiver)]
        [TestCase(CharacteristicPointType.ShoulderTopOutside, ConversionHelper.CpShoulderTopOutside)]
        [TestCase(CharacteristicPointType.ShoulderBaseOutside, ConversionHelper.CpShoulderBaseOutside)]
        [TestCase(CharacteristicPointType.DikeTopAtRiver, ConversionHelper.CpDikeTopAtRiver)]
        [TestCase(CharacteristicPointType.DikeLine, ConversionHelper.CpDikeLine)]
        [TestCase(CharacteristicPointType.TrafficLoadOutside, ConversionHelper.CpTrafficLoadOutside)]
        [TestCase(CharacteristicPointType.TrafficLoadInside, ConversionHelper.CpTrafficLoadInside)]
        [TestCase(CharacteristicPointType.DikeTopAtPolder, ConversionHelper.CpDikeTopAtPolder)]
        [TestCase(CharacteristicPointType.ShoulderBaseInside, ConversionHelper.CpShoulderBaseInside)]
        [TestCase(CharacteristicPointType.ShoulderTopInside, ConversionHelper.CpShoulderTopInside)]
        [TestCase(CharacteristicPointType.DikeToeAtPolder, ConversionHelper.CpDikeToeAtPolder)]
        [TestCase(CharacteristicPointType.DitchDikeSide, ConversionHelper.CpDitchDikeSide)]
        [TestCase(CharacteristicPointType.BottomDitchDikeSide, ConversionHelper.CpBottomDitchDikeSide)]
        [TestCase(CharacteristicPointType.BottomDitchPolderSide, ConversionHelper.CpBottomDitchPolderSide)]
        [TestCase(CharacteristicPointType.DitchPolderSide, ConversionHelper.CpDitchPolderSide)]
        [TestCase(CharacteristicPointType.SurfaceLevelInside, ConversionHelper.CpSurfaceLevelInside)]
        public void CanConvertToInputPointType(CharacteristicPointType characteristicPointType, int inputPointType)
        {
            Assert.AreEqual(inputPointType, ConversionHelper.ConvertToInputPointType(characteristicPointType));
        }

        [Test]
        [TestCase(0, WaterpressureInterpolationModel.Automatic)]
        [TestCase(1, WaterpressureInterpolationModel.Hydrostatic)]
        public void CanConvertToWaterpressureInterpolationModel(int inputInterpolationModel, WaterpressureInterpolationModel interpolationModel)
        {
            Assert.AreEqual(interpolationModel, ConversionHelper.ConvertToWaterpressureInterpolationModel(inputInterpolationModel));
        }

        [Test]
        [TestCase(SoilProfileType.ProfileType1D, 0)]
        [TestCase(SoilProfileType.ProfileType2D, 1)]
        [TestCase(SoilProfileType.ProfileTypeStiFile, 2)]
        public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, int inputSoilGeometryType)
        {
            Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilGeometryType(soilProfileType));
        }

        [Test]
        [TestCase(0, SoilProfileType.ProfileType1D)]
        [TestCase(1, SoilProfileType.ProfileType2D)]
        [TestCase(2, SoilProfileType.ProfileTypeStiFile)]
        public void CanConvertToSoilGeometryType(int inputSoilGeometryType, SoilProfileType soilProfileType)
        {
            Assert.AreEqual(soilProfileType, ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType));
        }

        [Test]
        [TestCase(FailureMechanismSystemType.StabilityInside, 0)]
        [TestCase(FailureMechanismSystemType.StabilityOutside, 1)]
        [TestCase(FailureMechanismSystemType.Piping, 2)]
        [TestCase(FailureMechanismSystemType.HorizontalBalance, 3)]
        public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
        {
            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
        }

        [Test]
        [TestCase(0, FailureMechanismSystemType.StabilityInside)]
        [TestCase(1, FailureMechanismSystemType.StabilityOutside)]
        [TestCase(2, FailureMechanismSystemType.Piping)]
        [TestCase(3, FailureMechanismSystemType.HorizontalBalance)]
        public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
        {
            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
        }

        [Test]
        [TestCase(AnalysisType.AdaptGeometry, InputAnalysisType.AdaptGeometry)]
        [TestCase(AnalysisType.NoAdaption, InputAnalysisType.NoAdaption)]
        public void CanConvertToInputAnalysisType(AnalysisType analysisType, InputAnalysisType inputAnalysisType)
        {
            Assert.AreEqual(inputAnalysisType, ConversionHelper.ConvertToInputAnalysisType(analysisType));
        }

        [Test]
        [TestCase(InputAnalysisType.AdaptGeometry, AnalysisType.AdaptGeometry)]
        [TestCase(InputAnalysisType.NoAdaption, AnalysisType.NoAdaption)]
        public void CanConvertToAnalysisType(InputAnalysisType inputAnalysisType, AnalysisType analysisType)
        {
            Assert.AreEqual(analysisType, ConversionHelper.ConvertToAnalysisType(inputAnalysisType));
        }

        [Test]
        [TestCase(MStabZonesType.NoZones, ConversionHelper.InputZoneTypeNoZones)]
        [TestCase(MStabZonesType.ZoneAreas, ConversionHelper.InputZoneTypeZoneAreas)]
        [TestCase(MStabZonesType.ForbiddenZone, ConversionHelper.InputZoneTypesForbiddenZones)]
        public void CanConvertToInputZoneType(MStabZonesType zoneType, int inputZoneType)
        {
            Assert.AreEqual(inputZoneType, ConversionHelper.ConvertToInputZoneType(zoneType));
        }

        [Test]
        [TestCase(ConversionHelper.InputZoneTypeNoZones, MStabZonesType.NoZones)]
        [TestCase(ConversionHelper.InputZoneTypeZoneAreas, MStabZonesType.ZoneAreas)]
        [TestCase(ConversionHelper.InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone)]
        public void CanConvertToZoneType(int inputZoneType, MStabZonesType zoneType)
        {
            Assert.AreEqual(zoneType, ConversionHelper.ConvertToZoneType(inputZoneType));
        }

        [Test]
        [TestCase(LogMessageType.Error, MessageMessageType.Error)]
        [TestCase(LogMessageType.Debug, MessageMessageType.Info)]
        [TestCase(LogMessageType.FatalError, MessageMessageType.Error)]
        [TestCase(LogMessageType.Info, MessageMessageType.Info)]
        [TestCase(LogMessageType.Trace, MessageMessageType.Info)]
        [TestCase(LogMessageType.Warning, MessageMessageType.Warning)]
        public void CanConvertToInputMessageType(LogMessageType logMessageType, MessageMessageType messageType)
        {
            Assert.AreEqual(messageType, ConversionHelper.ConvertToInputMessageType(logMessageType));
        }

        [Test]
        [TestCase(MessageMessageType.Error, LogMessageType.Error)]
        [TestCase(MessageMessageType.Info, LogMessageType.Info)]
        [TestCase(MessageMessageType.Warning, LogMessageType.Warning)]
        public void CanConvertToMessageType(MessageMessageType messageType, LogMessageType logMessageType)
        {
            Assert.AreEqual(logMessageType, ConversionHelper.ConvertToMessageType(messageType));
        }

        [Test]
        [TestCase(ShearStrengthModel.None, SoilShearStrengthModel.None)]
        [TestCase(ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi)]
        [TestCase(ShearStrengthModel.StressTable, SoilShearStrengthModel.StressTable)]
        [TestCase(ShearStrengthModel.PseudoValues, SoilShearStrengthModel.PseudoValues)]
        [TestCase(ShearStrengthModel.SuMeasured, SoilShearStrengthModel.SuMeasured)]
        [TestCase(ShearStrengthModel.SuCalculated, SoilShearStrengthModel.SuCalculated)]
        [TestCase(ShearStrengthModel.SuGradient, SoilShearStrengthModel.SuGradient)]
        [TestCase(ShearStrengthModel.SuCalculatedWithYield, SoilShearStrengthModel.SuCalculatedWithYield)]
        [TestCase(ShearStrengthModel.CPhiOrSuCalculated, SoilShearStrengthModel.CPhiOrSuCalculated)]
        public void CanConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel, SoilShearStrengthModel soilShearStrengthModel)
        {
            Assert.AreEqual(soilShearStrengthModel, ConversionHelper.ConvertToSoilShearStrengthModel(shearStrengthModel));
        }

        [Test]
        [TestCase(SoilShearStrengthModel.None, ShearStrengthModel.None)]
        [TestCase(SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
        [TestCase(SoilShearStrengthModel.StressTable, ShearStrengthModel.StressTable)]
        [TestCase(SoilShearStrengthModel.PseudoValues, ShearStrengthModel.PseudoValues)]
        [TestCase(SoilShearStrengthModel.SuMeasured, ShearStrengthModel.SuMeasured)]
        [TestCase(SoilShearStrengthModel.SuCalculated, ShearStrengthModel.SuCalculated)]
        [TestCase(SoilShearStrengthModel.SuGradient, ShearStrengthModel.SuGradient)]
        [TestCase(SoilShearStrengthModel.SuCalculatedWithYield, ShearStrengthModel.SuCalculatedWithYield)]
        [TestCase(SoilShearStrengthModel.CPhiOrSuCalculated, ShearStrengthModel.CPhiOrSuCalculated)]
        public void CanConvertToShearStrengthModel(SoilShearStrengthModel soilShearStrengthModel, ShearStrengthModel shearStrengthModel)
        {
            Assert.AreEqual(shearStrengthModel, ConversionHelper.ConvertToShearStrengthModel(soilShearStrengthModel));
        }

        [Test]
        [TestCase(DilatancyType.Zero, SoilDilatancyType.Zero)]
        [TestCase(DilatancyType.Phi, SoilDilatancyType.Phi)]
        [TestCase(DilatancyType.MinusPhi, SoilDilatancyType.MinusPhi)]
        public void CanConvertToSoilDilatancyType(DilatancyType dilatancyType, SoilDilatancyType soilDilatancyType)
        {
            Assert.AreEqual(soilDilatancyType, ConversionHelper.ConvertToSoilDilatancyType(dilatancyType));
        }

        [Test]
        [TestCase(SoilDilatancyType.Zero, DilatancyType.Zero)]
        [TestCase(SoilDilatancyType.Phi, DilatancyType.Phi)]
        [TestCase(SoilDilatancyType.MinusPhi, DilatancyType.MinusPhi)]
        public void CanConvertToDilatancyType(SoilDilatancyType soilDilatancyType, DilatancyType dilatancyType)
        {
            Assert.AreEqual(dilatancyType, ConversionHelper.ConvertToDilatancyType(soilDilatancyType));
        }

    }
}