// Copyright (C) Stichting Deltares 2023. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
// 
// You should have received a copy of the GNU 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.Io.XmlInput;
using Deltares.DamEngine.Io.XmlOutput;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Extensions;
using Deltares.Standard.Logging;

namespace Deltares.Dam.Data.DamEngineIo;

/// <summary>
///     Converts types from Dam Engine class to Input serializer class and vice versa
/// </summary>
public static class ConversionHelper
{
    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>The enumerated constants for input failure mechanism stability inside</summary>
    public const int InputFailureMechanismStabilityInside = 0;

    public const int InputFailureMechanismStabilityOutside = 1;
    public const int InputFailureMechanismPiping = 2;

    /// <summary>The enumerated constants for input segment failure mechanism stability inside</summary>
    public const int InputSegmentFailureMechanismAll = 0;

    public const int InputSegmentFailureMechanismStability = 1;
    public const int InputSegmentFailureMechanismPiping = 2;

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

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

    /// <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>
    ///     The input search method bee swarm
    /// </summary>
    public const int InputSearchMethodBeeSwarm = 2;

    /// <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>
    ///     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>
    ///     The load situation dry
    /// </summary>
    public const int LoadSituationDry = 0;

    /// <summary>
    ///     The load situation wet
    /// </summary>
    public const int LoadSituationWet = 1;

    /// <summary>
    ///     The dike dry sensitivity none
    /// </summary>
    public const int DikeDrySensitivityNone = 0;

    /// <summary>
    ///     The dike dry sensitivity dry
    /// </summary>
    public const int DikeDrySensitivityDry = 1;

    /// <summary>
    ///     The hydraulic shortcut type hydraulic shortcut
    /// </summary>
    public const int HydraulicShortcutTypeHydraulicShortcut = 0;

    /// <summary>
    ///     The hydraulic shortcut type no hydraulic shortcut
    /// </summary>
    public const int HydraulicShortcutTypeNoHydraulicShortcut = 1;

    /// <summary>
    ///     The uplift type uplift
    /// </summary>
    public const int UpliftTypeUplift = 0;

    /// <summary>
    ///     The uplift type no uplift
    /// </summary>
    public const int UpliftTypeNoUplift = 1;

    /// <summary>
    ///     The m stab model type bishop
    /// </summary>
    public const int MStabModelTypeBishop = 0;

    /// <summary>
    ///     The m stab model type spencer
    /// </summary>
    public const int MStabModelTypeSpencer = 1;

    /// <summary>
    ///     The m stab model type fellenius
    /// </summary>
    public const int MStabModelTypeFellenius = 2;

    /// <summary>
    ///     The m stab model type uplift van
    /// </summary>
    public const int MStabModelTypeUpliftVan = 3;

    /// <summary>
    ///     The m stab model type uplift spencer
    /// </summary>
    public const int MStabModelTypeUpliftSpencer = 4;

    /// <summary>
    ///     The m stab model type bishop random field
    /// </summary>
    public const int MStabModelTypeBishopRandomField = 5;

    /// <summary>
    ///     The m stab model type bishop uplift van
    /// </summary>
    public const int MStabModelTypeBishopUpliftVan = 7;

    /// <summary>
    ///     The scenario type scenario01
    /// </summary>
    public const int ScenarioTypeScenario01 = 0;

    /// <summary>
    ///     The scenario type scenario02
    /// </summary>
    public const int ScenarioTypeScenario02 = 1;

    /// <summary>
    ///     The scenario type scenario03
    /// </summary>
    public const int ScenarioTypeScenario03 = 2;

    /// <summary>
    ///     The scenario type scenario04
    /// </summary>
    public const int ScenarioTypeScenario04 = 3;

    /// <summary>
    ///     The scenario type scenario05
    /// </summary>
    public const int ScenarioTypeScenario05 = 4;

    /// <summary>
    ///     The scenario type scenario06
    /// </summary>
    public const int ScenarioTypeScenario06 = 5;

    /// <summary>
    ///     The scenario type scenario07
    /// </summary>
    public const int ScenarioTypeScenario07 = 6;

    /// <summary>
    ///     The scenario type scenario08
    /// </summary>
    public const int ScenarioTypeScenario08 = 7;

    /// <summary>
    ///     The scenario type scenario09
    /// </summary>
    public const int ScenarioTypeScenario09 = 8;

    /// <summary>
    ///     The scenario type scenario10
    /// </summary>
    public const int ScenarioTypeScenario10 = 9;

    /// <summary>
    ///     The scenario type scenario11
    /// </summary>
    public const int ScenarioTypeScenario11 = 10;

    /// <summary>
    ///     The piping model type bligh
    /// </summary>
    public const int PipingModelTypeBligh = 0;

    /// <summary>
    ///     The piping model type sellmeijer
    /// </summary>
    public const int PipingModelTypeSellmeijer = 1;

    /// <summary>
    ///     The piping model type sellmeijer4 forces
    /// </summary>
    public const int PipingModelTypeSellmeijer4Forces = 2;

    /// <summary>
    ///     The piping model type wti2017
    /// </summary>
    public const int PipingModelTypeWti2017 = 3;

    /// <summary>
    ///     Constants for translating to Enums TimeStepUnit
    /// </summary>
    public const uint TimeStepUnitSecond = 0;

    public const uint TimeStepUnitMinute = 1;
    public const uint TimeStepUnitHour = 2;
    public const uint TimeStepUnitDay = 3;
    public const uint TimeStepUnitMonth = 4;
    public const uint TimeStepUnitWeek = 5;
    public const uint TimeStepUnitYear = 6;
    public const uint TimeStepUnitNonequidistant = 7;

    /// <summary>
    ///     Constants for translating to Enums PlLineType
    /// </summary>
    public const uint PlLineTypePl1 = 1;

    public const uint PlLineTypePl2 = 2;
    public const uint PlLineTypePl3 = 3;
    public const uint PlLineTypePl4 = 4;

    /// <summary>
    ///     Constants for translating to Enums SensorType
    /// </summary>
    public const uint SensorTypePiezometricHead = 0;

    public const uint SensorTypeWaterLevel = 1;
    public const uint SensorTypePolderLevel = 2;

    /// <summary>
    ///     Constants for translating to Enums DataSourceTypeSensors
    /// </summary>
    public const uint DataSourceTypeSensorsIgnore = 0;

    public const uint DataSourceTypeSensorsLocationData = 1;
    public const uint DataSourceTypeSensorsSensor = 2;

    /// <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.Design, DamProjectType.Design
            },
            {
                InputDamProjectType.Operational, DamProjectType.Calamity
            }
        };
        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)
    {
        if (damProjectType == DamProjectType.DamLiveConfiguration)
        {
            damProjectType = DamProjectType.Calamity;
        }

        var translationTable = new Dictionary<DamProjectType, InputDamProjectType>
        {
            {
                DamProjectType.Design, InputDamProjectType.Design
            },
            {
                DamProjectType.Calamity, 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 the type of to dam point.
    /// </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 type of to input point.
    /// </summary>
    /// <param name="characteristicPointType">Type of the characteristic point.</param>
    /// <returns></returns>
    public static int ConvertToInputPointType(CharacteristicPointType characteristicPointType)
    {
        var translationTable = new Dictionary<CharacteristicPointType, int>
        {
            // The following types do not have a meaning in DAM, so should be mapped to CpNone
            {
                CharacteristicPointType.BottomRiverChannel, CpNone
            },
            {
                CharacteristicPointType.InsertRiverChannel, CpNone
            },
            {
                CharacteristicPointType.ForelandStart, CpNone
            },
            {
                CharacteristicPointType.DunesBoundaryProfile, CpNone
            },
            {
                CharacteristicPointType.DunesTransectLocation, CpNone
            },
            // The following types are DAM related, so should be translated
            {
                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 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];
    }

    /// <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 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 ConvertToInputSoilProfileType(SoilProfileType soilProfileType)
    {
        var translationTable = new Dictionary<SoilProfileType, int>
        {
            {
                SoilProfileType.SoilProfile1D, 0
            },
            {
                SoilProfileType.SoilProfile2D, 1
            },
            {
                SoilProfileType.SoilGeometryStiFile, 2
            }
        };
        return translationTable[soilProfileType];
    }

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

    /// <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
            }
        };
        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
            }
        };
        return translationTable[failureMechanismSystemType];
    }

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

    /// <summary>
    ///     Converts the input segment failure mechanism type to the Dam segment failure mechanism type .
    /// </summary>
    /// <param name="failureMechanismSystemType">Type of the failure mechanism system.</param>
    /// <returns></returns>
    public static FailureMechanismSystemType ConvertToSegmentFailureMechanismType(int failureMechanismSystemType)
    {
        if (failureMechanismSystemType == InputSegmentFailureMechanismAll)
        {
            throw new ConversionException(typeof(FailureMechanismSystemType), failureMechanismSystemType);
        }

        var translationTable = new Dictionary<int, FailureMechanismSystemType>
        {
            {
                InputSegmentFailureMechanismStability, FailureMechanismSystemType.StabilityInside
            },
            {
                InputSegmentFailureMechanismPiping, FailureMechanismSystemType.Piping
            }
        };
        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.Sellmeijer, InputPipingModelType.SellmeijerVnk
            },
            {
                PipingModelType.Sellmeijer4Forces, InputPipingModelType.Sellmeijer4Forces
            },
            {
                PipingModelType.Wti2017, InputPipingModelType.WtiSellmeijerRevised
            }
        };
        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.Sellmeijer
            },
            {
                InputPipingModelType.Sellmeijer4Forces, PipingModelType.Sellmeijer4Forces
            },
            {
                InputPipingModelType.WtiSellmeijerRevised, PipingModelType.Wti2017
            }
        };
        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 stability model to the output stability model.
    /// </summary>
    /// <param name="stabilityModelType">Type of the stability model.</param>
    /// <returns></returns>
    public static DesignResultStabilityDesignResultsStabilityModelType ConvertToOutputStabilityModelType(MStabModelType stabilityModelType)
    {
        var translationTable = new Dictionary<MStabModelType, DesignResultStabilityDesignResultsStabilityModelType>
        {
            {
                MStabModelType.Bishop, DesignResultStabilityDesignResultsStabilityModelType.Bishop
            },
            {
                MStabModelType.UpliftVan, DesignResultStabilityDesignResultsStabilityModelType.UpliftVan
            },
            {
                MStabModelType.BishopUpliftVan, DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan
            }
        };
        return translationTable[stabilityModelType];
    }

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

    /// <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>
    ///     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.ForbiddenZone, InputZoneTypesForbiddenZones
            }
        };
        if ((zoneType != MStabZonesType.NoZones) && (zoneType != MStabZonesType.ForbiddenZone))
        {
            zoneType = MStabZonesType.NoZones;
        }

        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
            },
            {
                InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone
            }
        };
        return translationTable[inputZoneType];
    }

    /// <summary>
    ///     Converts the Dam message type to the input message type.
    /// </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 input message type to the Dam message type.
    /// </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>
    ///     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
            },
            {
                MStabSearchMethod.BeeSwarm, InputSearchMethodBeeSwarm
            }
        };
        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
            },
            {
                InputSearchMethodBeeSwarm, MStabSearchMethod.BeeSwarm
            }
        };
        return translationTable[searchMethod];
    }

    /// <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 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>
    ///     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 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.CuMeasured, SoilShearStrengthModel.SuMeasured
            },
            {
                ShearStrengthModel.CuCalculated, SoilShearStrengthModel.SuCalculated
            },
            {
                ShearStrengthModel.CuGradient, SoilShearStrengthModel.SuGradient
            },
            {
                ShearStrengthModel.CuCalculatedYield, SoilShearStrengthModel.SuCalculatedWithYield
            },
            {
                ShearStrengthModel.CPhiOrCuCalculated, SoilShearStrengthModel.CPhiOrSuCalculated
            }
        };
        return translationTable[shearStrengthModel];
    }

    /// <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.CuMeasured
            },
            {
                SoilShearStrengthModel.SuCalculated, ShearStrengthModel.CuCalculated
            },
            {
                SoilShearStrengthModel.SuGradient, ShearStrengthModel.CuGradient
            },
            {
                SoilShearStrengthModel.SuCalculatedWithYield, ShearStrengthModel.CuCalculatedYield
            },
            {
                SoilShearStrengthModel.CPhiOrSuCalculated, ShearStrengthModel.CPhiOrCuCalculated
            }
        };
        return translationTable[soilShearStrengthModel];
    }
    
    /// <summary>
    ///     Converts the shear strength model.
    /// </summary>
    /// <param name="shearStrengthModel">Type of the soil.</param>
    /// <returns></returns>
    public static ShearStrengthModel ConvertToShearStrengthModel(string shearStrengthModel)
    {
        var translationTable = new Dictionary<string, ShearStrengthModel>
        {
            {
                "None", ShearStrengthModel.None
            },
            {
                "C phi", ShearStrengthModel.CPhi
            },
            {
                "Stress table", ShearStrengthModel.StressTable
            },
            {
                "Pseudo values", ShearStrengthModel.PseudoValues
            },
            {
                "Su measured", ShearStrengthModel.CuMeasured
            },
            {
                "Su calculated", ShearStrengthModel.CuCalculated
            },
            {
                "Su gradient", ShearStrengthModel.CuGradient
            },
            {
                "Su calculated with yield", ShearStrengthModel.CuCalculatedYield
            },
            {
                "C phi or Su calculated", ShearStrengthModel.CPhiOrCuCalculated
            }
        };
        return translationTable[shearStrengthModel];
    }    

    /// <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];
    }

    /// <summary>
    ///     Converts the input StabilityDesignMethod to the Dam StabilityDesignMethod.
    /// </summary>
    /// <param name="stabilityDesignMethod">The stability design method.</param>
    /// <returns></returns>
    public static StabilityDesignMethod ConvertToDamStabilityDesignMethod(LocationDesignOptionsStabilityDesignMethod stabilityDesignMethod)
    {
        var translationTable = new Dictionary<LocationDesignOptionsStabilityDesignMethod, StabilityDesignMethod>
        {
            {
                LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption
            },
            {
                LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption
            }
        };
        return translationTable[stabilityDesignMethod];
    }

    /// <summary>
    ///     Converts the Dam StabilityDesignMethod to the input StabilityDesignMethod.
    /// </summary>
    /// <param name="stabilityDesignMethod">The stability design method.</param>
    /// <returns></returns>
    public static LocationDesignOptionsStabilityDesignMethod ConvertToInputStabilityDesignMethod(StabilityDesignMethod stabilityDesignMethod)
    {
        var translationTable = new Dictionary<StabilityDesignMethod, LocationDesignOptionsStabilityDesignMethod>
        {
            {
                StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption
            },
            {
                StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption
            }
        };
        return translationTable[stabilityDesignMethod];
    }

    /// <summary>
    ///     Converts to Load Situation.
    /// </summary>
    /// <param name="inputLoadSituation">The input Load Situation.</param>
    /// <returns></returns>
    public static LoadSituation ConvertToLoadSituation(int inputLoadSituation)
    {
        var translationTable = new Dictionary<int, LoadSituation>
        {
            {
                LoadSituationDry, LoadSituation.Dry
            },
            {
                LoadSituationWet, LoadSituation.Wet
            }
        };
        return translationTable[inputLoadSituation];
    }

    /// <summary>
    ///     Converts to output LoadSituation.
    /// </summary>
    /// <param name="loadSituation">The Load Situation.</param>
    /// <returns></returns>
    public static int ConvertToOutputLoadSituation(LoadSituation loadSituation)
    {
        var translationTable = new Dictionary<LoadSituation, int>
        {
            {
                LoadSituation.Dry, LoadSituationDry
            },
            {
                LoadSituation.Wet, LoadSituationWet
            }
        };
        return translationTable[loadSituation];
    }

    /// <summary>
    ///     Converts to Uplift Type.
    /// </summary>
    /// <param name="inputUpliftType">The input UpliftType.</param>
    /// <returns></returns>
    public static UpliftType ConvertToUpliftType(int inputUpliftType)
    {
        var translationTable = new Dictionary<int, UpliftType>
        {
            {
                UpliftTypeUplift, UpliftType.Uplift
            },
            {
                UpliftTypeNoUplift, UpliftType.NoUplift
            }
        };
        return translationTable[inputUpliftType];
    }

    /// <summary>
    ///     Converts to output Uplift Type.
    /// </summary>
    /// <param name="upliftType">The UpliftType.</param>
    /// <returns></returns>
    public static int ConvertToOutputUpliftType(UpliftType upliftType)
    {
        var translationTable = new Dictionary<UpliftType, int>
        {
            {
                UpliftType.Uplift, UpliftTypeUplift
            },
            {
                UpliftType.NoUplift, UpliftTypeNoUplift
            }
        };
        return translationTable[upliftType];
    }

    /// <summary>
    ///     Converts to MStab Model Type.
    /// </summary>
    /// <param name="inputMStabModelType">The input MStabModelType.</param>
    /// <returns></returns>
    public static MStabModelType ConvertToMStabModelType(int inputMStabModelType)
    {
        var translationTable = new Dictionary<int, MStabModelType>
        {
            {
                MStabModelTypeBishop, MStabModelType.Bishop
            },
            {
                MStabModelTypeSpencer, MStabModelType.Spencer
            },
            {
                MStabModelTypeFellenius, MStabModelType.Fellenius
            },
            {
                MStabModelTypeUpliftVan, MStabModelType.UpliftVan
            },
            {
                MStabModelTypeUpliftSpencer, MStabModelType.UpliftSpencer
            },
            {
                MStabModelTypeBishopRandomField, MStabModelType.BishopRandomField
            },
            {
                MStabModelTypeBishopUpliftVan, MStabModelType.BishopUpliftVan
            }
        };
        return translationTable[inputMStabModelType];
    }

    /// <summary>
    ///     Converts to output MStabModelType.
    /// </summary>
    /// <param name="mStabModelType">The UpliftType.</param>
    /// <returns></returns>
    public static int ConvertToOutputMStabModelType(MStabModelType mStabModelType)
    {
        var translationTable = new Dictionary<MStabModelType, int>
        {
            {
                MStabModelType.Bishop, MStabModelTypeBishop
            },
            {
                MStabModelType.Spencer, MStabModelTypeSpencer
            },
            {
                MStabModelType.Fellenius, MStabModelTypeFellenius
            },
            {
                MStabModelType.UpliftVan, MStabModelTypeUpliftVan
            },
            {
                MStabModelType.UpliftSpencer, MStabModelTypeUpliftSpencer
            },
            {
                MStabModelType.BishopRandomField, MStabModelTypeBishopRandomField
            },
            {
                MStabModelType.BishopUpliftVan, MStabModelTypeBishopUpliftVan
            }
        };
        return translationTable[mStabModelType];
    }

    /// <summary>
    ///     Converts to Piping Model Type.
    /// </summary>
    /// <param name="inputPipingModelType">The input PipingModelType.</param>
    /// <returns></returns>
    public static PipingModelType ConvertToPipingModelType(int inputPipingModelType)
    {
        var translationTable = new Dictionary<int, PipingModelType>
        {
            {
                PipingModelTypeBligh, PipingModelType.Bligh
            },
            {
                PipingModelTypeSellmeijer, PipingModelType.Sellmeijer
            },
            {
                PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces
            },
            {
                PipingModelTypeWti2017, PipingModelType.Wti2017
            }
        };
        return translationTable[inputPipingModelType];
    }

    /// <summary>
    ///     Converts to output PipingModelType.
    /// </summary>
    /// <param name="pipingModelType">The UpliftType.</param>
    /// <returns></returns>
    public static int ConvertToOutputPipingModelType(PipingModelType pipingModelType)
    {
        var translationTable = new Dictionary<PipingModelType, int>
        {
            {
                PipingModelType.Bligh, PipingModelTypeBligh
            },
            {
                PipingModelType.Sellmeijer, PipingModelTypeSellmeijer
            },
            {
                PipingModelType.Sellmeijer4Forces, PipingModelTypeSellmeijer4Forces
            },
            {
                PipingModelType.Wti2017, PipingModelTypeWti2017
            }
        };
        return translationTable[pipingModelType];
    }

    /// <summary>
    ///     Converts the input TimeStepUnit to the TimeStepUnit.
    /// </summary>
    /// <param name="timeStepUnit">The time step unit.</param>
    /// <returns></returns>
    public static TimeStepUnit ConvertToTimeStepUnit(uint timeStepUnit)
    {
        var translationTable = new Dictionary<uint, TimeStepUnit>
        {
            {
                TimeStepUnitSecond, TimeStepUnit.Second
            },
            {
                TimeStepUnitMinute, TimeStepUnit.Minute
            },
            {
                TimeStepUnitHour, TimeStepUnit.Hour
            },
            {
                TimeStepUnitDay, TimeStepUnit.Day
            },
            {
                TimeStepUnitMonth, TimeStepUnit.Month
            },
            {
                TimeStepUnitWeek, TimeStepUnit.Week
            },
            {
                TimeStepUnitYear, TimeStepUnit.Year
            },
            {
                TimeStepUnitNonequidistant, TimeStepUnit.Nonequidistant
            }
        };
        return translationTable[timeStepUnit];
    }

    /// <summary>
    ///     Converts the TimeStepUnit to the input TimeStepUnit.
    /// </summary>
    /// <param name="timeStepUnit">The time step unit.</param>
    /// <returns></returns>
    public static uint ConvertToInputTimeStepUnit(TimeStepUnit timeStepUnit)
    {
        var translationTable = new Dictionary<TimeStepUnit, uint>
        {
            {
                TimeStepUnit.Second, TimeStepUnitSecond
            },
            {
                TimeStepUnit.Minute, TimeStepUnitMinute
            },
            {
                TimeStepUnit.Hour, TimeStepUnitHour
            },
            {
                TimeStepUnit.Day, TimeStepUnitDay
            },
            {
                TimeStepUnit.Month, TimeStepUnitMonth
            },
            {
                TimeStepUnit.Week, TimeStepUnitWeek
            },
            {
                TimeStepUnit.Year, TimeStepUnitYear
            },
            {
                TimeStepUnit.Nonequidistant, TimeStepUnitNonequidistant
            }
        };
        return translationTable[timeStepUnit];
    }

    /// <summary>
    ///     Converts the input plLineType to Dam plLineType.
    /// </summary>
    /// <param name="plLineType">Type of the pl line.</param>
    /// <returns>plLineType</returns>
    public static PLLineType ConvertToPlLineType(uint plLineType)
    {
        var translationTable = new Dictionary<uint, PLLineType>
        {
            {
                PlLineTypePl1, PLLineType.PL1
            },
            {
                PlLineTypePl2, PLLineType.PL2
            },
            {
                PlLineTypePl3, PLLineType.PL3
            },
            {
                PlLineTypePl4, PLLineType.PL4
            }
        };
        return translationTable[plLineType];
    }

    /// <summary>
    ///     Converts the Dam plLineType to input plLineType.
    /// </summary>
    /// <param name="plLineType">Type of the pl line.</param>
    /// <returns>plLineType as integer</returns>
    public static uint ConvertToInputPlLineType(PLLineType plLineType)
    {
        var translationTable = new Dictionary<PLLineType, uint>
        {
            {
                PLLineType.PL1, PlLineTypePl1
            },
            {
                PLLineType.PL2, PlLineTypePl2
            },
            {
                PLLineType.PL3, PlLineTypePl3
            },
            {
                PLLineType.PL4, PlLineTypePl4
            }
        };
        return translationTable[plLineType];
    }

    /// <summary>
    ///     Converts the Dam sensorType to input sensorType.
    /// </summary>
    /// <param name="sensorType">Type of the sensor.</param>
    /// <returns>sensorType</returns>
    public static SensorType ConvertToSensorType(uint sensorType)
    {
        var translationTable = new Dictionary<uint, SensorType>
        {
            {
                SensorTypePiezometricHead, SensorType.PiezometricHead
            },
            {
                SensorTypePolderLevel, SensorType.PolderLevel
            },
            {
                SensorTypeWaterLevel, SensorType.WaterLevel
            }
        };
        return translationTable[sensorType];
    }

    /// <summary>
    ///     Converts the Dam sensorType to input sensorType.
    /// </summary>
    /// <param name="sensorType">Type of the sensor.</param>
    /// <returns>sensorType as integer</returns>
    public static uint ConvertToInputSensorType(SensorType sensorType)
    {
        var translationTable = new Dictionary<SensorType, uint>
        {
            {
                SensorType.PiezometricHead, SensorTypePiezometricHead
            },
            {
                SensorType.PolderLevel, SensorTypePolderLevel
            },
            {
                SensorType.WaterLevel, SensorTypeWaterLevel
            }
        };
        return translationTable[sensorType];
    }

    /// <summary>
    ///     Converts the Dam DataSourceTypeSensors to input DataSourceTypeSensors.
    /// </summary>
    /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
    /// <returns>
    ///     DataSourceTypeSensors
    /// </returns>
    public static DataSourceTypeSensors ConvertToDataSourceTypeSensors(uint dataSourceTypeSensors)
    {
        var translationTable = new Dictionary<uint, DataSourceTypeSensors>
        {
            {
                DataSourceTypeSensorsIgnore, DataSourceTypeSensors.Ignore
            },
            {
                DataSourceTypeSensorsLocationData, DataSourceTypeSensors.LocationData
            },
            {
                DataSourceTypeSensorsSensor, DataSourceTypeSensors.Sensor
            }
        };
        return translationTable[dataSourceTypeSensors];
    }

    /// <summary>
    ///     Converts the Dam DataSourceType to input DataSourceType.
    /// </summary>
    /// <param name="dataSourceTypeSensors">The data source type sensors.</param>
    /// <returns>
    ///     DataSourceType as integer
    /// </returns>
    public static uint ConvertToInputDataSourceTypeSensors(DataSourceTypeSensors dataSourceTypeSensors)
    {
        var translationTable = new Dictionary<DataSourceTypeSensors, uint>
        {
            {
                DataSourceTypeSensors.Ignore, DataSourceTypeSensorsIgnore
            },
            {
                DataSourceTypeSensors.LocationData, DataSourceTypeSensorsLocationData
            },
            {
                DataSourceTypeSensors.Sensor, DataSourceTypeSensorsSensor
            }
        };
        return translationTable[dataSourceTypeSensors];
    }

    /// <summary>
    ///     Converts the soil type.
    /// </summary>
    /// <param name="soilType">Type of the soil.</param>
    /// <returns></returns>
    public static SoilType ConvertToSoilType(string soilType)
    {
        var translationTable = new Dictionary<string, SoilType>
        {
            {
                "Sand", SoilType.Sand
            },
            {
                "Peat", SoilType.Peat
            },
            {
                "Loam", SoilType.Loam
            },
            {
                "Clay", SoilType.Clay
            },
            {
                "Gravel", SoilType.Gravel
            }
        };
        return translationTable[soilType];
    }
}