// 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 System.Collections.Generic;
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;

namespace Deltares.DamEngine.Interface
{
    /// <summary>
    /// Converts types from Dam class to Input serializer class and vice versa
    /// </summary>
    public static class ConversionHelper
    {
        /// <summary>
        /// Converts the type DamProjectType from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputDamProjectType">Type of the input object.</param>
        /// <returns>Dam Engine type</returns>
        public static DamProjectType ConvertToDamProjectType(InputDamProjectType inputDamProjectType)
        {
            var translationTable = new Dictionary<InputDamProjectType, DamProjectType>()
            {
                {
                    InputDamProjectType.Assessment, DamProjectType.Assessment
                },
                {
                    InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional
                },
                {
                    InputDamProjectType.Design, DamProjectType.Design
                },
                {
                    InputDamProjectType.Operational, DamProjectType.Operational
                }
            };
            return translationTable[inputDamProjectType];
        }

        /// <summary>
        /// Converts the type DamProjectType from Dam Engine type to input object type.
        /// </summary>
        /// <param name="damProjectType">Type of the dam project.</param>
        /// <returns>Type of the input object.</returns>
        public static InputDamProjectType ConvertToInputDamProjectType(DamProjectType damProjectType)
        {
            var translationTable = new Dictionary<DamProjectType, InputDamProjectType>()
            {
                {
                    DamProjectType.Assessment, InputDamProjectType.Assessment
                },
                {
                    DamProjectType.AssessmentRegional, InputDamProjectType.AssessmentRegional
                },
                {
                    DamProjectType.Design, InputDamProjectType.Design
                },
                {
                    DamProjectType.Operational, InputDamProjectType.Operational
                }
            };
            return translationTable[damProjectType];
        }

        /// <summary>
        /// Converts the type PLLineCreationMethod from Dam Engine type to input object type.
        /// </summary>
        /// <param name="plLineCreationMethod">Type of the dam project.</param>
        /// <returns>
        /// Type of the input object.
        /// </returns>
        public static LocationWaternetOptionsPhreaticLineCreationMethod ConvertToInputPhreaticLineCreationMethod(PLLineCreationMethod plLineCreationMethod)
        {
            var translationTable = new Dictionary<PLLineCreationMethod, LocationWaternetOptionsPhreaticLineCreationMethod>()
            {
                {
                    PLLineCreationMethod.ExpertKnowledgeLinearInDike, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike
                },
                {
                    PLLineCreationMethod.ExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD
                },
                {
                    PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD
                },
                {
                    PLLineCreationMethod.Sensors, LocationWaternetOptionsPhreaticLineCreationMethod.Sensors
                },
                {
                    PLLineCreationMethod.None, LocationWaternetOptionsPhreaticLineCreationMethod.None
                }
            };
            return translationTable[plLineCreationMethod];
        }

        /// <summary>
        /// Converts the type PLLineCreationMethod from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputPhreaticLineCreationMethod">Type of the input object.</param>
        /// <returns>
        /// Type of the dam object.
        /// </returns>
        public static PLLineCreationMethod ConvertToPhreaticLineCreationMethod(LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod)
        {
            var translationTable = new Dictionary<LocationWaternetOptionsPhreaticLineCreationMethod, PLLineCreationMethod>()
            {
                {
                    LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike, PLLineCreationMethod.ExpertKnowledgeLinearInDike
                },
                {
                    LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD, PLLineCreationMethod.ExpertKnowledgeRRD
                },
                {
                    LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, PLLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD
                },
                {
                    LocationWaternetOptionsPhreaticLineCreationMethod.Sensors, PLLineCreationMethod.Sensors
                },
                {
                    LocationWaternetOptionsPhreaticLineCreationMethod.None, PLLineCreationMethod.None
                }
            };
            return translationTable[inputPhreaticLineCreationMethod];
        }

        /// <summary>
        /// Converts the type IntrusionVerticalWaterPressureType from Dam Engine type to input object type.
        /// </summary>
        /// <param name="intrusionVerticalWaterPressureType">Type of the dam project.</param>
        /// <returns>
        /// Type of the input object.
        /// </returns>
        public static LocationWaternetOptionsIntrusionVerticalWaterPressure ConvertToInputIntrusionVerticalWaterPressure(IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType)
        {
            var translationTable = new Dictionary<IntrusionVerticalWaterPressureType, LocationWaternetOptionsIntrusionVerticalWaterPressure>()
            {
                {
                    IntrusionVerticalWaterPressureType.FullHydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic
                },
                {
                    IntrusionVerticalWaterPressureType.HydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic
                },
                {
                    IntrusionVerticalWaterPressureType.Linear, LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear
                },
                {
                    IntrusionVerticalWaterPressureType.SemiTimeDependent, LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent
                },
                {
                    IntrusionVerticalWaterPressureType.Standard, LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard
                }
            };
            return translationTable[intrusionVerticalWaterPressureType];
        }

        /// <summary>
        /// Converts the type IntrusionVerticalWaterPressureType from input object type to Dam Engine type.
        /// </summary>
        /// <param name="inputIntrusionVerticalWaterPressure">Type of the input object.</param>
        /// <returns>
        /// Type of the dam object.
        /// </returns>
        public static IntrusionVerticalWaterPressureType ConvertToIntrusionVerticalWaterPressure(LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressure)
        {
            var translationTable = new Dictionary<LocationWaternetOptionsIntrusionVerticalWaterPressure, IntrusionVerticalWaterPressureType>()
            {
                {
                    LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic, IntrusionVerticalWaterPressureType.FullHydroStatic
                },
                {
                    LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic, IntrusionVerticalWaterPressureType.HydroStatic
                },
                {
                    LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear, IntrusionVerticalWaterPressureType.Linear
                },
                {
                    LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent, IntrusionVerticalWaterPressureType.SemiTimeDependent
                },
                {
                    LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard, IntrusionVerticalWaterPressureType.Standard
                }
            };
            return translationTable[inputIntrusionVerticalWaterPressure];
        }

        /// <summary>
        /// Converts to output calculation result.
        /// </summary>
        /// <param name="calculationResult">Type of the dam project.</param>
        /// <returns></returns>
        public static int ConvertToOutputCalculationResult(CalculationResult calculationResult)
        {
            var translationTable = new Dictionary<CalculationResult, int>()
            {
                {
                    CalculationResult.NoRun, 0
                },
                {
                    CalculationResult.Succeeded, 1
                },
                {
                    CalculationResult.NoInput, 2
                },
                {
                    CalculationResult.NoLicense, 3
                },
                {
                    CalculationResult.UserAbort, 4
                },
                {
                    CalculationResult.InvalidInputStructure, 5
                },
                {
                    CalculationResult.InvalidInputData, 6
                },
                {
                    CalculationResult.RunFailed, 7
                },
                {
                    CalculationResult.UnexpectedError, 8
                }
            };
            return translationTable[calculationResult];
        }

        /// <summary>
        /// Converts to calculation result.
        /// </summary>
        /// <param name="calculationResult">The calculation result.</param>
        /// <returns></returns>
        public static CalculationResult ConvertToCalculationResult(int calculationResult)
        {
            var translationTable = new Dictionary<int, CalculationResult>()
            {
                {
                    0, CalculationResult.NoRun
                },
                {
                    1, CalculationResult.Succeeded
                },
                {
                    2, CalculationResult.NoInput
                },
                {
                    3, CalculationResult.NoLicense
                },
                {
                    4, CalculationResult.UserAbort
                },
                {
                    5, CalculationResult.InvalidInputStructure
                },
                {
                    6, CalculationResult.InvalidInputData
                },
                {
                    7, CalculationResult.RunFailed
                },
                {
                    8, CalculationResult.UnexpectedError
                }
            };
            return translationTable[calculationResult];
        }

        public const int CpNone = 0; //
        public const int CpSurfaceLevelOutside = 1; // Maaiveld buitenwaarts
        public const int CpDikeToeAtRiver = 5; // Teen dijk buitenwaarts
        public const int CpShoulderTopOutside = 6; // Kruin buitenberm
        public const int CpShoulderBaseOutside = 7; // Insteek buitenberm
        public const int CpDikeTopAtRiver = 8; // Kruin buitentalud
        public const int CpDikeLine = 9; // referentielijn
        public const int CpTrafficLoadOutside = 10; // Verkeersbelasting kant buitenwaarts
        public const int CpTrafficLoadInside = 11; // Verkeersbelasting kant binnenwaarts
        public const int CpDikeTopAtPolder = 12; // Kruin binnentalud
        public const int CpShoulderBaseInside = 13; // Insteek binnenberm
        public const int CpShoulderTopInside = 14; // Kruin binnenberm
        public const int CpDikeToeAtPolder = 15; // Teen dijk binnenwaarts
        public const int CpDitchDikeSide = 16; // Insteek sloot dijkzijde
        public const int CpBottomDitchDikeSide = 17; // Slootbodem dijkzijde
        public const int CpBottomDitchPolderSide = 18; // Slootbodem polderzijde
        public const int CpDitchPolderSide = 19; // Insteek sloot polderzijde
        public const int CpSurfaceLevelInside = 25; // Maaiveld binnenwaarts        

        /// <summary>
        /// Converts the input characteristic point type to the Dam characteristic point type
        /// </summary>
        /// <param name="inputPointType">Type of the input point.</param>
        /// <returns></returns>
        public static CharacteristicPointType ConvertToDamPointType(int inputPointType)
        {
            var translationTable = new Dictionary<int, CharacteristicPointType>()
            {
                {
                    CpNone, CharacteristicPointType.None
                },
                {
                    CpSurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside
                },
                {
                    CpDikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver
                },
                {
                    CpShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside
                },
                {
                    CpShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside
                },
                {
                    CpDikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver
                },
                {
                    CpDikeLine, CharacteristicPointType.DikeLine
                },
                {
                    CpTrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside
                },
                {
                    CpTrafficLoadInside, CharacteristicPointType.TrafficLoadInside
                },
                {
                    CpDikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder
                },
                {
                    CpShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside
                },
                {
                    CpShoulderTopInside, CharacteristicPointType.ShoulderTopInside
                },
                {
                    CpDikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder
                },
                {
                    CpDitchDikeSide, CharacteristicPointType.DitchDikeSide
                },
                {
                    CpBottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide
                },
                {
                    CpBottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide
                },
                {
                    CpDitchPolderSide, CharacteristicPointType.DitchPolderSide
                },
                {
                    CpSurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside
                }
            };
            return translationTable[inputPointType];
        }

        /// <summary>
        /// Converts the Dam characteristic point type to the input characteristic point type
        /// </summary>
        /// <param name="characteristicPointType">Type of the characteristic point.</param>
        /// <returns></returns>
        public static int ConvertToInputPointType(CharacteristicPointType characteristicPointType)
        {
            var translationTable = new Dictionary<CharacteristicPointType, int>()
            {
                {
                    CharacteristicPointType.None, CpNone
                },
                {
                    CharacteristicPointType.SurfaceLevelOutside, CpSurfaceLevelOutside
                },
                {
                    CharacteristicPointType.DikeToeAtRiver, CpDikeToeAtRiver
                },
                {
                    CharacteristicPointType.ShoulderTopOutside, CpShoulderTopOutside
                },
                {
                    CharacteristicPointType.ShoulderBaseOutside, CpShoulderBaseOutside
                },
                {
                    CharacteristicPointType.DikeTopAtRiver, CpDikeTopAtRiver
                },
                {
                    CharacteristicPointType.DikeLine, CpDikeLine
                },
                {
                    CharacteristicPointType.TrafficLoadOutside, CpTrafficLoadOutside
                },
                {
                    CharacteristicPointType.TrafficLoadInside, CpTrafficLoadInside
                },
                {
                    CharacteristicPointType.DikeTopAtPolder, CpDikeTopAtPolder
                },
                {
                    CharacteristicPointType.ShoulderBaseInside, CpShoulderBaseInside
                },
                {
                    CharacteristicPointType.ShoulderTopInside, CpShoulderTopInside
                },
                {
                    CharacteristicPointType.DikeToeAtPolder, CpDikeToeAtPolder
                },
                {
                    CharacteristicPointType.DitchDikeSide, CpDitchDikeSide
                },
                {
                    CharacteristicPointType.BottomDitchDikeSide, CpBottomDitchDikeSide
                },
                {
                    CharacteristicPointType.BottomDitchPolderSide, CpBottomDitchPolderSide
                },
                {
                    CharacteristicPointType.DitchPolderSide, CpDitchPolderSide
                },
                {
                    CharacteristicPointType.SurfaceLevelInside, CpSurfaceLevelInside
                }
            };
            return translationTable[characteristicPointType];
        }

        /// <summary>
        /// Converts to waterpressure interpolation model.
        /// </summary>
        /// <param name="inputWaterpressureInterpolationModel">The input waterpressure interpolation model.</param>
        /// <returns></returns>
        public static WaterpressureInterpolationModel ConvertToWaterpressureInterpolationModel(int inputWaterpressureInterpolationModel)
        {
            var translationTable = new Dictionary<int, WaterpressureInterpolationModel>()
            {
                {
                    0, WaterpressureInterpolationModel.Automatic
                },
                {
                    1, WaterpressureInterpolationModel.Hydrostatic
                }
            };
            return translationTable[inputWaterpressureInterpolationModel];
        }

        /// <summary>
        /// Converts to input waterpressure interpolation model.
        /// </summary>
        /// <param name="waterpressureInterpolationModel">The waterpressure interpolation model.</param>
        /// <returns></returns>
        public static int ConvertToInputWaterpressureInterpolationModel(WaterpressureInterpolationModel waterpressureInterpolationModel)
        {
            var translationTable = new Dictionary<WaterpressureInterpolationModel, int>()
            {
                {
                    WaterpressureInterpolationModel.Automatic, 0
                },
                {
                    WaterpressureInterpolationModel.Hydrostatic, 1
                }
            };
            return translationTable[waterpressureInterpolationModel];
        }

        /// <summary>
        /// Converts the Dam profile type to the input profile type
        /// </summary>
        /// <param name="soilProfileType">Type of the soil geometry.</param>
        /// <returns></returns>
        public static int ConvertToInputSoilGeometryType(SoilProfileType soilProfileType)
        {
            var translationTable = new Dictionary<SoilProfileType, int>()
            {
                {
                    SoilProfileType.ProfileType1D, 0
                },
                {
                    SoilProfileType.ProfileType2D, 1
                },
                {
                    SoilProfileType.ProfileTypeStiFile, 2
                }
            };
            return translationTable[soilProfileType];
        }

        /// <summary>
        /// Converts the input profile type to the Dam profile type
        /// </summary>
        /// <param name="soilGeometryType">Type of the soil geometry.</param>
        /// <returns></returns>
        public static SoilProfileType ConvertToSoilGeometryType(int soilGeometryType)
        {
            var translationTable = new Dictionary<int, SoilProfileType>()
            {
                {
                    0, SoilProfileType.ProfileType1D
                },
                {
                    1, SoilProfileType.ProfileType2D
                },
                {
                    2, SoilProfileType.ProfileTypeStiFile
                }
            };
            return translationTable[soilGeometryType];
        }

        public const int InputFailureMechanismStabilityInside = 0;
        public const int InputFailureMechanismStabilityOutside = 1;
        public const int InputFailureMechanismPiping = 2;
        public const int InputFailureMechanismHorizontalBalance = 3;

        /// <summary>
        /// Converts the Dam failure mechanism type to the input failure mechanism type .
        /// </summary>
        /// <param name="segmentFailureMechanismType">Type of the segment failure mechanism.</param>
        /// <returns></returns>
        public static int ConvertToInputFailureMechanismSystemType(FailureMechanismSystemType segmentFailureMechanismType)
        {
            var translationTable = new Dictionary<FailureMechanismSystemType, int>()
            {
                {
                    FailureMechanismSystemType.StabilityInside, InputFailureMechanismStabilityInside
                },
                {
                    FailureMechanismSystemType.StabilityOutside, InputFailureMechanismStabilityOutside
                },
                {
                    FailureMechanismSystemType.Piping, InputFailureMechanismPiping
                },
                {
                    FailureMechanismSystemType.HorizontalBalance, InputFailureMechanismHorizontalBalance
                }
            };
            return translationTable[segmentFailureMechanismType];
        }

        /// <summary>
        /// Converts the input failure mechanism type to the Dam failure mechanism type .
        /// </summary>
        /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
        /// <returns></returns>
        public static FailureMechanismSystemType ConvertToFailureMechanismSystemType(int failureMechanismSystemType)
        {
            var translationTable = new Dictionary<int, FailureMechanismSystemType>()
            {
                {
                    InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside
                },
                {
                    InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside
                },
                {
                    InputFailureMechanismPiping, FailureMechanismSystemType.Piping
                },
                {
                    InputFailureMechanismHorizontalBalance, FailureMechanismSystemType.HorizontalBalance
                }
            };
            return translationTable[failureMechanismSystemType];
        }

        /// <summary>
        /// Converts the Dam piping model to the input piping model.
        /// </summary>
        /// <param name="pipingModelType">Type of the piping model.</param>
        /// <returns></returns>
        public static InputPipingModelType ConvertToInputPipingModelType(PipingModelType pipingModelType)
        {
            var translationTable = new Dictionary<PipingModelType, InputPipingModelType>()
            {
                {
                    PipingModelType.Bligh, InputPipingModelType.Bligh
                },
                {
                    PipingModelType.SellmeijerVnk, InputPipingModelType.SellmeijerVnk
                },
                {
                    PipingModelType.Sellmeijer4Forces, InputPipingModelType.Sellmeijer4Forces
                }
            };
            return translationTable[pipingModelType];
        }

        /// <summary>
        /// Converts the input piping model to the Dam piping model.
        /// </summary>
        /// <param name="inputPipingModelType">Type of the input piping model.</param>
        /// <returns></returns>
        public static PipingModelType ConvertToPipingModelType(InputPipingModelType inputPipingModelType)
        {
            var translationTable = new Dictionary<InputPipingModelType, PipingModelType>()
            {
                {
                    InputPipingModelType.Bligh, PipingModelType.Bligh
                },
                {
                    InputPipingModelType.SellmeijerVnk, PipingModelType.SellmeijerVnk
                },
                {
                    InputPipingModelType.Sellmeijer4Forces, PipingModelType.Sellmeijer4Forces
                }
            };
            return translationTable[inputPipingModelType];
        }

        /// <summary>
        /// Converts the Dam stability model to the input stability model.
        /// </summary>
        /// <param name="stabilityModelType">Type of the stability model.</param>
        /// <returns></returns>
        public static InputStabilityModelType ConvertToInputStabilityModelType(MStabModelType stabilityModelType)
        {
            var translationTable = new Dictionary<MStabModelType, InputStabilityModelType>()
            {
                {
                    MStabModelType.Bishop, InputStabilityModelType.Bishop
                },
                {
                    MStabModelType.UpliftVan, InputStabilityModelType.UpliftVan
                },
                {
                    MStabModelType.BishopUpliftVan, InputStabilityModelType.BishopUpliftVan
                }
            };
            return translationTable[stabilityModelType];
        }

        /// <summary>
        /// Converts the input stability model to the Dam stability model.
        /// </summary>
        /// <param name="inputStabilityModelType">Type of the input stability model.</param>
        /// <returns></returns>
        public static MStabModelType ConvertToStabilityModelType(InputStabilityModelType inputStabilityModelType)
        {
            var translationTable = new Dictionary<InputStabilityModelType, MStabModelType>()
            {
                {
                    InputStabilityModelType.Bishop, MStabModelType.Bishop
                },
                {
                    InputStabilityModelType.UpliftVan, MStabModelType.UpliftVan
                },
                {
                    InputStabilityModelType.BishopUpliftVan, MStabModelType.BishopUpliftVan
                }
            };
            return translationTable[inputStabilityModelType];
        }

        /// <summary>
        /// Converts the Dam analysis type to the input analysis type.
        /// </summary>
        /// <param name="analysisType">Type of the analysis.</param>
        /// <returns></returns>
        public static InputAnalysisType ConvertToInputAnalysisType(AnalysisType analysisType)
        {
            var translationTable = new Dictionary<AnalysisType, InputAnalysisType>()
            {
                {
                    AnalysisType.NoAdaption, InputAnalysisType.NoAdaption
                },
                {
                    AnalysisType.AdaptGeometry, InputAnalysisType.AdaptGeometry
                }
            };
            return translationTable[analysisType];
        }

        /// <summary>
        /// Converts the input analysis type to the Dam analysis type.
        /// </summary>
        /// <param name="inputAnalysisType">Type of the input analysis.</param>
        /// <returns></returns>
        public static AnalysisType ConvertToAnalysisType(InputAnalysisType inputAnalysisType)
        {
            var translationTable = new Dictionary<InputAnalysisType, AnalysisType>()
            {
                {
                    InputAnalysisType.NoAdaption, AnalysisType.NoAdaption
                },
                {
                    InputAnalysisType.AdaptGeometry, AnalysisType.AdaptGeometry
                }
            };
            return translationTable[inputAnalysisType];
        }

        /// <summary>
        /// The input zone type no zones
        /// </summary>
        public const int InputZoneTypeNoZones = 0;

        /// <summary>
        /// The input zone type zone areas
        /// </summary>
        public const int InputZoneTypeZoneAreas = 1;

        /// <summary>
        /// The input zone types forbidden zones
        /// </summary>
        public const int InputZoneTypesForbiddenZones = 2;

        /// <summary>
        /// Converts the type of to input zone.
        /// </summary>
        /// <param name="zoneType">Type of the zone.</param>
        /// <returns></returns>
        public static int ConvertToInputZoneType(MStabZonesType zoneType)
        {
            var translationTable = new Dictionary<MStabZonesType, int>()
            {
                {
                    MStabZonesType.NoZones, InputZoneTypeNoZones
                },
                {
                    MStabZonesType.ZoneAreas, InputZoneTypeZoneAreas
                },
                {
                    MStabZonesType.ForbiddenZone, InputZoneTypesForbiddenZones
                }
            };
            return translationTable[zoneType];
        }

        /// <summary>
        /// Converts the type of to zone.
        /// </summary>
        /// <param name="inputZoneType">Type of the input zone.</param>
        /// <returns></returns>
        public static MStabZonesType ConvertToZoneType(int inputZoneType)
        {
            var translationTable = new Dictionary<int, MStabZonesType>()
            {
                {
                    InputZoneTypeNoZones, MStabZonesType.NoZones
                },
                {
                    InputZoneTypeZoneAreas, MStabZonesType.ZoneAreas
                },
                {
                    InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone
                }
            };
            return translationTable[inputZoneType];
        }

        /// <summary>
        /// The input search method grid
        /// </summary>
        public const int InputSearchMethodGrid = 0;

        /// <summary>
        /// The input search method genetic
        /// </summary>
        public const int InputSearchMethodGenetic = 1;

        /// <summary>
        /// Converts to input search method.
        /// </summary>
        /// <param name="searchMethod">The search method.</param>
        /// <returns></returns>
        public static int ConvertToInputSearchMethod(MStabSearchMethod searchMethod)
        {
            var translationTable = new Dictionary<MStabSearchMethod, int>()
            {
                {
                    MStabSearchMethod.Grid, InputSearchMethodGrid
                },
                {
                    MStabSearchMethod.GeneticAlgorithm, InputSearchMethodGenetic
                }
            };
            return translationTable[searchMethod];
        }

        /// <summary>
        /// Converts to search method.
        /// </summary>
        /// <param name="searchMethod">The search method.</param>
        /// <returns></returns>
        public static MStabSearchMethod ConvertToSearchMethod(int searchMethod)
        {
            var translationTable = new Dictionary<int, MStabSearchMethod>()
            {
                {
                    InputSearchMethodGrid, MStabSearchMethod.Grid
                },
                {
                    InputSearchMethodGenetic, MStabSearchMethod.GeneticAlgorithm
                }
            };
            return translationTable[searchMethod];
        }

        /// <summary>
        /// Converts the type of to input message.
        /// </summary>
        /// <param name="messageType">Type of the message.</param>
        /// <returns></returns>
        public static MessageMessageType ConvertToInputMessageType(LogMessageType messageType)
        {
            var translationTable = new Dictionary<LogMessageType, MessageMessageType>()
            {
                {
                    LogMessageType.Warning, MessageMessageType.Warning
                },
                {
                    LogMessageType.Debug, MessageMessageType.Info
                },
                {
                    LogMessageType.Error, MessageMessageType.Error
                },
                {
                    LogMessageType.FatalError, MessageMessageType.Error
                },
                {
                    LogMessageType.Info, MessageMessageType.Info
                },
                {
                    LogMessageType.Trace, MessageMessageType.Info
                }
            };
            return translationTable[messageType];
        }

        /// <summary>
        /// Converts the type of to message.
        /// </summary>
        /// <param name="validationResultMessageType">Type of the validation result message.</param>
        /// <returns></returns>
        public static LogMessageType ConvertToMessageType(MessageMessageType validationResultMessageType)
        {
            var translationTable = new Dictionary<MessageMessageType, LogMessageType>()
            {
                {
                    MessageMessageType.Warning, LogMessageType.Warning
                },
                {
                    MessageMessageType.Error, LogMessageType.Error
                },
                {
                    MessageMessageType.Info, LogMessageType.Info
                }
            };
            return translationTable[validationResultMessageType];
        }


        /// <summary>
        /// The input grid type automatic
        /// </summary>
        public const int InputGridTypeAutomatic = 0;

        /// <summary>
        /// The input grid type specified
        /// </summary>
        public const int InputGridTypeSpecified = 1;

        /// <summary>
        /// Converts to input grid determination.
        /// </summary>
        /// <param name="gridType">Type of the grid.</param>
        /// <returns></returns>
        public static int ConvertToInputGridDetermination(GridSizeDetermination gridType)
        {
            var translationTable = new Dictionary<GridSizeDetermination, int>()
            {
                {
                    GridSizeDetermination.Automatic, InputGridTypeAutomatic
                },
                {
                    GridSizeDetermination.Specified, InputGridTypeSpecified
                }
            };

            return translationTable[gridType];
        }

        /// <summary>
        /// Converts the shear strength model to soil shear strength model.
        /// </summary>
        /// <param name="shearStrengthModel">The shear strength model.</param>
        /// <returns></returns>
        public static SoilShearStrengthModel ConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel)
        {
            var translationTable = new Dictionary<ShearStrengthModel, SoilShearStrengthModel>()
                                               {
                                                   {ShearStrengthModel.None, SoilShearStrengthModel.None},
                                                   {ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi},
                                                   {ShearStrengthModel.StressTable, SoilShearStrengthModel.StressTable},
                                                   {ShearStrengthModel.PseudoValues, SoilShearStrengthModel.PseudoValues},
                                                   {ShearStrengthModel.SuMeasured, SoilShearStrengthModel.SuMeasured},
                                                   {ShearStrengthModel.SuCalculated, SoilShearStrengthModel.SuCalculated},
                                                   {ShearStrengthModel.SuGradient, SoilShearStrengthModel.SuGradient},
                                                   {ShearStrengthModel.SuCalculatedWithYield, SoilShearStrengthModel.SuCalculatedWithYield},
                                                   {ShearStrengthModel.CPhiOrSuCalculated, SoilShearStrengthModel.CPhiOrSuCalculated},
                                               };
            return translationTable[shearStrengthModel];                
        }
            

        /// <summary>
        /// Converts to grid determination.
        /// </summary>
        /// <param name="gridType">Type of the grid.</param>
        /// <returns></returns>
        public static GridSizeDetermination ConvertToGridDetermination(int gridType)
        {
            var translationTable = new Dictionary<int, GridSizeDetermination>()
            {
                {
                    InputGridTypeAutomatic, GridSizeDetermination.Automatic
                },
                {
                    InputGridTypeSpecified, GridSizeDetermination.Specified
                }
            };
            return translationTable[gridType];
        }

        /// <summary>
        /// The input tangent lines on boundaty lines
        /// </summary>
        public const int InputTangentLinesOnBoundatyLines = 0;

        /// <summary>
        /// The input tangent lines specified
        /// </summary>
        public const int InputTangentLinesSpecified = 1;

        /// <summary>
        /// Converts to input tangent lines definition.
        /// </summary>
        /// <param name="tangentLineType">Type of the tangent line.</param>
        /// <returns></returns>
        public static int ConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType)
        {
            var translationTable = new Dictionary<TangentLinesDefinition, int>()
            {
                {
                    TangentLinesDefinition.OnBoundaryLines, InputGridTypeAutomatic
                },
                {
                    TangentLinesDefinition.Specified, InputGridTypeSpecified
                }
            };
            return translationTable[tangentLineType];
        }

        /// <summary>
        /// Converts to tangent lines definition.
        /// </summary>
        /// <param name="tangentLineType">Type of the tangent line.</param>
        /// <returns></returns>
        public static TangentLinesDefinition ConvertToTangentLinesDefinition(int tangentLineType)
        {
            var translationTable = new Dictionary<int, TangentLinesDefinition>()
            {
                {
                    InputGridTypeAutomatic, TangentLinesDefinition.OnBoundaryLines
                },
                {
                    InputGridTypeSpecified, TangentLinesDefinition.Specified
                }
            };
            return translationTable[tangentLineType];
        }
    
        /// <summary>
        /// Converts the soil shear strength model to shear strength model.
        /// </summary>
        /// <param name="soilShearStrengthModel">The soil shear strength model.</param>
        /// <returns></returns>
        public static ShearStrengthModel ConvertToShearStrengthModel(SoilShearStrengthModel soilShearStrengthModel)
        {
            var translationTable = new Dictionary<SoilShearStrengthModel, ShearStrengthModel>()
                                               {
                                                   {SoilShearStrengthModel.None, ShearStrengthModel.None},
                                                   {SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi},
                                                   {SoilShearStrengthModel.StressTable, ShearStrengthModel.StressTable},
                                                   {SoilShearStrengthModel.PseudoValues, ShearStrengthModel.PseudoValues},
                                                   {SoilShearStrengthModel.SuMeasured, ShearStrengthModel.SuMeasured},
                                                   {SoilShearStrengthModel.SuCalculated, ShearStrengthModel.SuCalculated},
                                                   {SoilShearStrengthModel.SuGradient, ShearStrengthModel.SuGradient},
                                                   {SoilShearStrengthModel.SuCalculatedWithYield, ShearStrengthModel.SuCalculatedWithYield},
                                                   {SoilShearStrengthModel.CPhiOrSuCalculated, ShearStrengthModel.CPhiOrSuCalculated},
                                               };
            return translationTable[soilShearStrengthModel];
        }

        /// <summary>
        /// Converts the dilatancy type to soil dilatancy dilatancy.
        /// </summary>
        /// <param name="dilatancyType">Type of the dilatancy.</param>
        /// <returns></returns>
        public static SoilDilatancyType ConvertToSoilDilatancyType(DilatancyType dilatancyType)
        {
            var translationTable = new Dictionary<DilatancyType, SoilDilatancyType>()
                                               {
                                                   {DilatancyType.Zero, SoilDilatancyType.Zero},
                                                   {DilatancyType.Phi, SoilDilatancyType.Phi},
                                                   {DilatancyType.MinusPhi, SoilDilatancyType.MinusPhi},
                                               };
            return translationTable[dilatancyType];
        }

        /// <summary>
        /// Converts the soil dilatancy type to dilatancy type.
        /// </summary>
        /// <param name="soilDilatancyType">Type of the soil dilatancy.</param>
        /// <returns></returns>
        public static DilatancyType ConvertToDilatancyType(SoilDilatancyType soilDilatancyType)
        {
            var translationTable = new Dictionary<SoilDilatancyType, DilatancyType>()
                                               {
                                                   {SoilDilatancyType.Zero, DilatancyType.Zero},
                                                   {SoilDilatancyType.Phi, DilatancyType.Phi},
                                                   {SoilDilatancyType.MinusPhi, DilatancyType.MinusPhi},
                                               };
            return translationTable[soilDilatancyType];
        }

    }
}