// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Schema;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;

namespace Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon.Assemblers
{
    /// <summary>
    /// 
    /// </summary>    
    public class DamMStabAssembler :
        DtoDocumentAssembler<FailureMechanismParametersMStab, FailureMechanismParametersMStab>
    {
        #region Constant declarations

        /// <summary>
        /// Holds the common part of the path to the embedded resource
        /// </summary>
        private const string EmbeddedResourcePath = "Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon.Xsd";

        public const string XmlAttributeBottomLevel = "BottomLevel";
        public const string XmlAttributeBoundaryLayer = "BoundaryLayer";
        public const string XmlAttributeHasPhreaticLevel = "HasPhreaticLevel";
        public const string XmlAttributeID = "ID";
        public const string XmlAttributeIsPhreatic = "IsPhreatic";

        public const string XmlAttributeMStabFileName = "MStabFileName";
        public const string XmlAttributeName = "Name";
        public const string XmlAttributePhreaticLevel = "PhreaticLevel";
        public const string XmlAttributeSoilDBName = "SoilDBName";
        public const string XmlAttributeSoilID = "SoilID";
        public const string XmlAttributeTopLevel = "TopLevel";
        public const string XmlAttributeXCoord = "XCoord";
        public const string XmlAttributeXCoordinate = "XCoordinate";
        public const string XmlAttributeYCoord = "YCoord";
        public const string XmlAttributeYCoordinate = "YCoordinate";
        public const string XmlAttributeCharacteristicPointType = "CharacteristicPointType";
        public const string XmlElementExternalPLLines = "ExternalPLLines";
        public const string XmlElementLayer = "Layer";
        public const string XmlElementLayers = "Layers";
        public const string XmlAttributeSoilType = "SoilType";
        public const string XmlAttributeInBetweenSandLayerID = "InBetweenSandLayerID";
        public const string XmlAttributeBottomSandLayerID = "BottomSandLayerID";
        public const string XmlAttributeInfiltrationLayerID = "InfiltrationLayerID";

        /// <summary>
        /// Holds the xml element name
        /// </summary>
        public const string XmlElementName = "DamMStabDoc";

        public const string XmlElementNameInput = "DamMStabInput";

        /// <summary>
        /// Holds the xml namespace
        /// </summary>
        public const string XmlElementNamespace = "http://deltares.nl/2008/" + XmlSchemaName;

        public const string XmlElementNamespaceInput = "http://deltares.nl/2008/" + XmlSchemaNameInput;
        public const string XmlElementPLLine = "PLLine";
        public const string XmlElementPLPoint = "PLPoint";
        public const string XmlElementProfile = "Profile";
        public const string XmlElementSurfaceLine = "SurfaceLine";
        public const string XmlElementSurfacePoint = "SurfacePoint";
        public const string XmlElementCharacteristicPoints = "CharacteristicPoints";
        public const string XmlElementCharacteristicPoint = "CharacteristicPoint";
        public const string XmlElementZoneAreas = "ZoneAreas";
        public const string XmlElementForbiddenZone = "ForbiddenZone";
        public const string XmlElementSheetPiling = "SheetPiling";
        public const string XmlElementHorizontalBalanceArea = "HorizontalBalanceArea";
        public const string XmlElementSlipCircleDefinition = "SlipCircleDefinition";

        /// <summary>
        /// Holds the model xml element and attribute names
        /// </summary>
        public const string XmlElementModel = "Model";

        public const string XmlAttributeCalculationModel = "CalculationModel";
        public const string XmlAttributeShearStrength = "ShearStrength";
        public const string XmlAttributeProbabilistic = "Probabilistic";
        public const string XmlAttributeSearchMethod = "SearchMethod";
        public const string XmlAttributeGridPosition = "GridPosition";

        /// <summary>
        /// Holds the TrafficLoad xml element and attribute names
        /// </summary>
        public const string XmlElementTrafficLoad = "TrafficLoad";

        public const string XmlAttributeXCoordinateAtRiver = "XCoordinateAtRiver";
        public const string XmlAttributeXCoordinateAtPolder = "XCoordinateAtPolder";
        public const string XmlAttributeLoad = "Load";
        public const string XmlAttributeDegreeOfConsolidationSpecified = "DegreeOfConsolidationSpecified";
        public const string XmlAttributeDegreeOfConsolidation = "DegreeOfConsolidation";

        /// <summary>
        /// Holds the CalculationOptions xml element and attribute names
        /// </summary>
        public const string XmlElementCalculationOptions = "CalculationOptions";

        public const string XmlAttributeMinimalCircleDepth = "MinimalCircleDepth";
        public const string XmlAttributeZonesType = "ZonesType";

        /// <summary>
        /// Holds the GeometryCreationOptions xml element and attribute names
        /// </summary>
        public const string XmlElementGeometryCreationOptions = "GeometryCreationOptions";

        public const string XmlAttributeSoilGeometryType = "SoilGeometryType";
        public const string XmlAttributeSoilGeometry2DFilename = "SoilGeometry2DFilename";
        public const string XmlAttributeXOffsetSoilGeometry2DOrigin = "XOffsetSoilGeometry2DOrigin";
        public const string XmlAttributeMaterialForDike = "MaterialForDike";
        public const string XmlAttributeMaterialForShoulder = "MaterialForShoulder";
        public const string XmlAttributeIsDrySituation = "IsDrySituation";
        public const string XmlAttributePLLineAssignment = "PLLineAssignment";
        public const string XmlAttributeIntrusionVerticalWaterPressure = "IntrusionVerticalWaterPressure";
        public const string XmlAttributePenetrationLength = "PenetrationLength";
        public const string XmlAttributeIsDesign = "IsDesign";

        public const string XmlElementDesign = "Design";
        public const string XmlAttributeEmbankmentMaterialName = "EmbankmentMaterialName";
        public const string XmlAttributePreviousGeometry2DFilename = "PreviousGeometry2DFilename";
        /// <summary>
        /// Holds the name of the xml schema
        /// </summary>
        private const string XmlSchemaName = "DamMStabDocDefinition";

        private const string XmlSchemaNameInput = "DamMStabInputDefinition";

        /// <summary>
        /// Holds the xsd resource path 
        /// </summary>
        public const string XsdEmbeddedResourcePath = EmbeddedResourcePath + "." + XmlSchemaName + ".xsd";

        private const string XsdEmbeddedResourcePathInput = EmbeddedResourcePath + "." + XmlSchemaNameInput + ".xsd";

        #endregion

        /// <summary>
        /// 
        /// </summary>
        public DamMStabAssembler() :
            base(XmlElementName, XmlElementNamespace, XsdEmbeddedResourcePath)
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <returns></returns>
        public override XDocument CreateDataTransferObject(FailureMechanismParametersMStab failureMechanismParametersMStab)
        {
            XDocument doc = base.CreateDataTransferObject(failureMechanismParametersMStab);

            XNamespace tns = ElementNamespace;

            Location location = failureMechanismParametersMStab.Location;
            // Todo: Sheetpiling should be done correctly (SheetpilePointLevel vs SheetpileLength)
            // For now: disable this
            //if (location.SheetPileLength > 0.0)
            //{
            //    SheetPiling sheetPiling = new SheetPiling();
            //    sheetPiling.Length = location.SheetPileLength;
            //    sheetPiling.XCoordinate = location.SheetPilePoint.X;
            //    sheetPiling.YCoordinate = location.SheetPilePoint.Y;
            //    sheetPiling.ZCoordinate = location.SheetPilePoint.Z;
            //    damFailureMechanismeCalculation.FailureMechanismParametersMStab.MStabParameters.SheetPiling =
            //        sheetPiling;
            //}

            // DAMMStabInput
            var inputElement = new XElement(tns + XmlElementNameInput);
            doc.Root.Add(inputElement);

            XNamespace tnsb = XmlElementNamespaceInput;
            doc.Root.Add(new XAttribute(XNamespace.Xmlns + "tnsb", tnsb.NamespaceName));

            // Soil database
            inputElement.Add(new XAttribute(XmlAttributeMStabFileName,failureMechanismParametersMStab.MStabParameters.ProjectFileName));
            inputElement.Add(new XAttribute(XmlAttributeSoilDBName, failureMechanismParametersMStab.MStabParameters.SoilDatabaseName));

            // Surface line
            XElement surfaceLineElement = GetSurfaceLineElement(failureMechanismParametersMStab, tnsb);
            inputElement.Add(surfaceLineElement);

            // Surface line
            XElement characteristicPointsElement = GetCharacteristicPointsElement(failureMechanismParametersMStab, tnsb);
            inputElement.Add(characteristicPointsElement);

            // External PL lines
            XElement externalPLLinesElement = GetExternalPlLinesElement(failureMechanismParametersMStab, tnsb);
            inputElement.Add(externalPLLinesElement);

            // Model
            XElement modelElement = GetModelElement(failureMechanismParametersMStab, tnsb);
            inputElement.Add(modelElement);

            // Zone Area
            if (failureMechanismParametersMStab.MStabParameters.ZoneAreas != null)
            {
                XElement zoneAreasElement = GetZoneAreasElement(failureMechanismParametersMStab.MStabParameters.ZoneAreas, tnsb);
                inputElement.Add(zoneAreasElement);
            }

            // Forbidden zone
            if (failureMechanismParametersMStab.MStabParameters.ForbiddenZone != null)
            {
                XElement forbiddenZoneElement =
                    GetForbiddenZoneElement(failureMechanismParametersMStab.MStabParameters.ForbiddenZone, tnsb);
                inputElement.Add(forbiddenZoneElement);
            }

            // Traffic load
            if (
                failureMechanismParametersMStab.SurfaceLine.HasAnnotation(CharacteristicPointType.TrafficLoadInside) &&
                failureMechanismParametersMStab.SurfaceLine.HasAnnotation(CharacteristicPointType.TrafficLoadOutside))
            {
                XElement trafficLoadElement = GetTrafficLoadElement(failureMechanismParametersMStab, tnsb);
                inputElement.Add(trafficLoadElement);
            }

            // Calculation Options
            if (failureMechanismParametersMStab.MStabParameters.CalculationOptions !=
                null)
            {
                XElement calculationOptionsElement = GetCalculationOptionsElement(failureMechanismParametersMStab, tnsb);
                inputElement.Add(calculationOptionsElement);
            }

            // GeometryCreationOptions Options
            if (failureMechanismParametersMStab.MStabParameters.GeometryCreationOptions != null)
            {
                XElement geometryCreationOptionsElement = GetGeometryCreationOptionsElement(failureMechanismParametersMStab, tnsb);
                inputElement.Add(geometryCreationOptionsElement);
            }

            // SheetPiling
            if (failureMechanismParametersMStab.MStabParameters.SheetPiling != null)
            {
                XElement sheetPilingElement = GetSheetPilingElement(failureMechanismParametersMStab.MStabParameters.SheetPiling, tnsb);
                inputElement.Add(sheetPilingElement);
            }

            // Horizontal Balance Area
            if (failureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea != null)
            {
                XElement horizontalBalanceAreaElement =
                    GetHorizontalBalanceAreaElement(failureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea, tnsb);
                inputElement.Add(horizontalBalanceAreaElement);
            }

            // Slip Circle Definition
            if (failureMechanismParametersMStab.MStabParameters.SlipCircleDefinition != null)
            {
                XElement slipCircleDefinitionElement = GetSlipCircleDefinitionElement(
                    failureMechanismParametersMStab.MStabParameters.SlipCircleDefinition, tnsb);
                inputElement.Add(slipCircleDefinitionElement);
            }

            // Design data
            if (failureMechanismParametersMStab.EmbankmentDesignParameters != null)
            {
                XElement designElement = GetDesignElement(failureMechanismParametersMStab, tnsb);
                inputElement.Add(designElement);
            }

            // Profile
            SoilProfile1D profile = failureMechanismParametersMStab.SoilProfile;
            if (profile != null)
            {
                var soilProfileAssembler = new SoilProfileAssembler<SoilLayer1D, Soil>();
                XNamespace tnsa = soilProfileAssembler.ElementNamespace;
                doc.Root.Add(new XAttribute(XNamespace.Xmlns + "tnsa", tnsa.NamespaceName));


                //TODO: Remove duplicate code. The method GetProfileElement should call the SoilProfileAssembler already defined in another namespace
                XElement profileElement = GetProfileElement(profile, tns, tnsa);
                //                XElement profileElement = soilProfileAssembler.CreateDataTransferObject(profile); //GetProfileElement(profile, tns, tnsa);
                //                profileElement.Name = tns.GetName(profileElement.Name.LocalName);// .SetNamespace(DamMStabAssembler.XmlElementProfile, tns.NamespaceName);
                doc.Root.Add(profileElement);
            }

            return doc;
        }

        private static XElement GetZoneAreasElement(MStabZoneAreas zoneAreas, XNamespace tns)
        {
            if (zoneAreas == null)
                throw new ArgumentNullException("zoneAreas");

            return zoneAreas.ToXElement(XmlElementZoneAreas, tns);
        }

        private static XElement GetForbiddenZoneElement(MStabForbiddenZone forbiddenZone, XNamespace tns)
        {
            if (forbiddenZone == null)
                throw new ArgumentNullException("forbiddenZone");

            return forbiddenZone.ToXElement(XmlElementForbiddenZone, tns);
        }

        private static XElement GetSheetPilingElement(SheetPiling sheetPiling, XNamespace tns)
        {
            if (sheetPiling == null)
                throw new ArgumentNullException("sheetPiling");

            return sheetPiling.ToXElement(XmlElementSheetPiling, tns);
        }

        private static XElement GetHorizontalBalanceAreaElement(HorizontalBalanceArea horizontalBalanceArea,
                                                                XNamespace tns)
        {
            if (horizontalBalanceArea == null)
                throw new ArgumentNullException("horizontalBalanceArea");

            return horizontalBalanceArea.ToXElement(XmlElementHorizontalBalanceArea, tns);
        }

        /// <summary>
        /// Gets the slip circle definition element.
        /// </summary>
        /// <param name="slipCircleDefinition">The slip circle definition.</param>
        /// <param name="tns">The namespace</param>
        /// <returns></returns>
        private static XElement GetSlipCircleDefinitionElement(SlipCircleDefinition slipCircleDefinition, XNamespace tns)
        {
            if (slipCircleDefinition == null)
                throw new ArgumentNullException("slipCircleDefinition");

            return slipCircleDefinition.ToXElement(XmlElementSlipCircleDefinition, tns);
        }

        #region Private Assembler Methods

        /// <summary>
        /// 
        /// </summary>
        /// <param name="profile"></param>
        /// <param name="tns"></param>
        /// <param name="tnsa"></param>
        /// <returns></returns>
        private static XElement GetProfileElement(SoilProfile1D profile, XNamespace tns,
                                                  XNamespace tnsa)
        {
            var profileElement = new XElement(tns + XmlElementProfile);
            profileElement.Add(new XAttribute(XmlAttributeName, profile.Name));
            // #Bka: just fake the missing params as these are not really relevant (not even PhreaticLevel as this is never given a value within Dam)
            profileElement.Add(new XAttribute(XmlAttributeXCoordinate, 0));
            profileElement.Add(new XAttribute(XmlAttributeYCoordinate, 0));
            profileElement.Add(new XAttribute(XmlAttributePhreaticLevel, 0));
            profileElement.Add(new XAttribute(XmlAttributeHasPhreaticLevel, false));
            profileElement.Add(new XAttribute(XmlAttributeBottomLevel, profile.BottomLevel));

            if (profile.Layers.Count > 0)
            {
                var layersElement = new XElement(tnsa + XmlElementLayers);
                GetProfileLayersElement(profile, tnsa, layersElement);
                profileElement.Add(layersElement);
            }

            // Bottom sand layer
            if (profile.BottomAquiferLayer != null)
                profileElement.Add(new XAttribute(XmlAttributeBottomSandLayerID, profile.BottomAquiferLayer.Name));
            // In-between sand layer
            if (profile.InBetweenAquiferLayer != null)
                profileElement.Add(new XAttribute(XmlAttributeInBetweenSandLayerID, profile.InBetweenAquiferLayer.Name));
            // Infiltration layer
            if (profile.InfiltrationLayer != null)
                profileElement.Add(new XAttribute(XmlAttributeInfiltrationLayerID, profile.InfiltrationLayer.Name));
            return profileElement;
        }

        // Assembles the layer elements for the profile
        private static void GetProfileLayersElement(SoilProfile1D profile, XNamespace tnsa,
                                                    XElement layersElement)
        {
            profile.EnsureUniqueLayerNames();
            foreach (SoilLayer1D layer in profile.Layers)
            {
                var layerElement = new XElement(tnsa + XmlElementLayer);
                layersElement.Add(layerElement);
                layerElement.Add(new XAttribute(XmlAttributeID, String.Format("{0}", layer.Name)));
                layerElement.Add(new XAttribute(XmlAttributeSoilID, layer.Soil.Name));
                layerElement.Add(new XAttribute(XmlAttributeTopLevel, layer.TopLevel));
            }
        }

        /// <summary>
        /// Assembles the pl lines
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetExternalPlLinesElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            XElement externalPLLinesElement = null;
            if (failureMechanismParametersMStab.PlLines != null)
            {
                externalPLLinesElement = new XElement(tnsb + XmlElementExternalPLLines);
                foreach (PlLineType plLineType in Enum.GetValues(typeof(PlLineType)))
                {
                    PlLine line = failureMechanismParametersMStab.PlLines.Lines[plLineType];
                    var PLLineElement = new XElement(tnsb + XmlElementPLLine);
                    externalPLLinesElement.Add(PLLineElement);
                    PLLineElement.Add(new XAttribute(XmlAttributeIsPhreatic, line.IsPhreatic));
                    PLLineElement.Add(new XAttribute(XmlAttributeBoundaryLayer, line.BoundaryLayer));
                    foreach (PlLinePoint point in line.Points)
                    {
                        var PLPointElement = new XElement(tnsb + XmlElementPLPoint);
                        PLPointElement.Add(new XAttribute(XmlAttributeXCoord, point.X));
                        PLPointElement.Add(new XAttribute(XmlAttributeYCoord, point.Z));
                        PLLineElement.Add(PLPointElement);
                    }
                }
            }
            return externalPLLinesElement;
        }

        /// <summary>
        /// Assembles the surface line element
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetSurfaceLineElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            var surfaceLineElement = new XElement(tnsb + XmlElementSurfaceLine);
            foreach (GeometryPoint point in failureMechanismParametersMStab.SurfaceLine.Geometry.Points)
            {
                var surfacePointElement = new XElement(tnsb + XmlElementSurfacePoint);
                surfacePointElement.Add(new XAttribute(XmlAttributeXCoord, point.X));
                surfacePointElement.Add(new XAttribute(XmlAttributeYCoord, point.Z));
                surfaceLineElement.Add(surfacePointElement);
            }
            return surfaceLineElement;
        }

        /// <summary>
        /// Assembles the characteristic points element
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetCharacteristicPointsElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            var characteristicPointsElement = new XElement(tnsb + XmlElementCharacteristicPoints);
            foreach (CharacteristicPointType characteristicPointType in Enum.GetValues(typeof(CharacteristicPointType)))
            {
                GeometryPoint point = failureMechanismParametersMStab.SurfaceLine.CharacteristicPoints.GetGeometryPoint(characteristicPointType);
                if (point != null)
                {
                    var characteristicPointElement = new XElement(tnsb + XmlElementCharacteristicPoint);
                    characteristicPointElement.Add(new XAttribute(XmlAttributeXCoord, point.X));
                    characteristicPointElement.Add(new XAttribute(XmlAttributeYCoord, point.Z));
                    characteristicPointElement.Add(new XAttribute(XmlAttributeCharacteristicPointType, characteristicPointType.ToString()));
                    characteristicPointsElement.Add(characteristicPointElement);
                }
                
            }
            return characteristicPointsElement;
        }


        /// <summary>
        /// Assembles the model element 
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetModelElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            return new XElement(tnsb + XmlElementModel,
                                new XAttribute(XmlAttributeCalculationModel, failureMechanismParametersMStab.MStabParameters.Model),
                                new XAttribute(XmlAttributeShearStrength, failureMechanismParametersMStab.MStabParameters.ShearStrength),
                                new XAttribute(XmlAttributeProbabilistic, failureMechanismParametersMStab.MStabParameters.IsProbabilistic),
                                new XAttribute(XmlAttributeSearchMethod, failureMechanismParametersMStab.MStabParameters.SearchMethod),
                                new XAttribute(XmlAttributeGridPosition, failureMechanismParametersMStab.MStabParameters.GridPosition.ToString().ToLower())
                );
        }

        /// <summary>
        /// Assembles the traffic load element
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetTrafficLoadElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            return new XElement(tnsb + XmlElementTrafficLoad,
                                new XAttribute(XmlAttributeXCoordinateAtRiver, failureMechanismParametersMStab.
                                                   SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X),
                                new XAttribute(XmlAttributeXCoordinateAtPolder, failureMechanismParametersMStab.
                                                   SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X),
                                new XAttribute(XmlAttributeLoad, failureMechanismParametersMStab.TrafficLoad),
                                new XAttribute(XmlAttributeDegreeOfConsolidationSpecified, failureMechanismParametersMStab.TrafficLoadDegreeOfConsolidation != null),
                                new XAttribute(XmlAttributeDegreeOfConsolidation, failureMechanismParametersMStab.TrafficLoadDegreeOfConsolidation ?? 0.0)
                );
        }

        /// <summary>
        /// Assembles the calculation options element
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetCalculationOptionsElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            return new XElement(tnsb + XmlElementCalculationOptions,
                                new XAttribute(XmlAttributeMinimalCircleDepth, failureMechanismParametersMStab.
                                                   MStabParameters.CalculationOptions.MinimalCircleDepth),
                                new XAttribute(XmlAttributeZonesType, failureMechanismParametersMStab.
                                                   MStabParameters.CalculationOptions.ZonesType.ToString())
                );
        }

        private static string ConvertSoilProfileTypeToClassicType(SoilProfileType soilProfileType)
        {
            switch (soilProfileType)
            {
                case SoilProfileType.ProfileType1D:
                    return "SoilGeometry1D";
                case SoilProfileType.ProfileType2D:
                    return "SoilGeometry2D";
                case SoilProfileType.ProfileTypeStiFile:
                    return "SoilGeometry2D";
            }
            return "";
        }

        /// <summary>
        /// Assembles the GeometryCreationOptions element 
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetGeometryCreationOptionsElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            string soilGeometryName = failureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.SoilGeometry2DFilename;
            soilGeometryName = (soilGeometryName == null ? "" : soilGeometryName);
            string materialForDike = failureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.MaterialForDike;
            materialForDike = (materialForDike == null ? "" : materialForDike);
            string materialForShoulder = failureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.MaterialForShoulder;
            materialForShoulder = (materialForShoulder == null ? "" : materialForShoulder);
            return new XElement(tnsb + XmlElementGeometryCreationOptions,
                new XAttribute(XmlAttributeSoilGeometryType, 
                    ConvertSoilProfileTypeToClassicType(failureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType)),
                new XAttribute(XmlAttributeSoilGeometry2DFilename, soilGeometryName),
                new XAttribute(XmlAttributeXOffsetSoilGeometry2DOrigin, failureMechanismParametersMStab.
                                    MStabParameters.GeometryCreationOptions.XOffsetSoilGeometry2DOrigin),
                new XAttribute(XmlAttributeMaterialForDike, materialForDike),
                new XAttribute(XmlAttributeMaterialForShoulder, materialForShoulder),
                new XAttribute(XmlAttributeIsDrySituation, false),
                new XAttribute(XmlAttributePLLineAssignment, failureMechanismParametersMStab.
                                    MStabParameters.GeometryCreationOptions.PlLineAssignment),
                new XAttribute(XmlAttributeIntrusionVerticalWaterPressure, failureMechanismParametersMStab.
                                    MStabParameters.GeometryCreationOptions.IntrusionVerticalWaterPressureType),
                new XAttribute(XmlAttributePenetrationLength, failureMechanismParametersMStab.
                                    MStabParameters.GeometryCreationOptions.PenetrationLength),
                new XAttribute(XmlAttributeIsDesign, failureMechanismParametersMStab.
                                    MStabParameters.GeometryCreationOptions.IsDesign));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="failureMechanismParametersMStab"></param>
        /// <param name="tnsb"></param>
        /// <returns></returns>
        private static XElement GetDesignElement(
            FailureMechanismParametersMStab failureMechanismParametersMStab, XNamespace tnsb)
        {
            string embankmentMaterialname = failureMechanismParametersMStab.EmbankmentDesignParameters.EmbankmentMaterialname;
            embankmentMaterialname = (embankmentMaterialname == null ? "" : embankmentMaterialname);
            string previousGeometry2DFilename = failureMechanismParametersMStab.EmbankmentDesignParameters.PreviousGeometry2DFilename;
            previousGeometry2DFilename = (previousGeometry2DFilename == null ? "" : previousGeometry2DFilename);

            return new XElement(tnsb + XmlElementDesign,
                                new XAttribute(XmlAttributeEmbankmentMaterialName, embankmentMaterialname),
                                new XAttribute(XmlAttributePreviousGeometry2DFilename, previousGeometry2DFilename));
        }



        #endregion

        #region Schema Validator Method

        public bool ValidateSchema(XDocument doc, out string message)
        {
            bool result = true;
            string errorMessage = String.Empty;

            // DAMMStabDefinition
            XmlSchemaSet schemas = new XmlSchemaSet();

            Stream xsdStream = Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePath);
            schemas.Add(XmlElementNamespace, XmlReader.Create(xsdStream));
            xsdStream = Common.GetEmbeddedFile(Assembly.GetExecutingAssembly(), XsdEmbeddedResourcePathInput);
            schemas.Add(XmlElementNamespaceInput, XmlReader.Create(xsdStream));

            Assembly assembly;
            string schemaName;
            string resourceName;

            // FileIdentificationDefinition
            var fileIdentificationAssembler = new FileIdentificationAssembler();
            if (!schemas.Contains(fileIdentificationAssembler.ElementNamespace))
            {
                assembly = fileIdentificationAssembler.GetType().Assembly;
                schemaName = Path.GetFileName(fileIdentificationAssembler.ElementNamespace);
                string schemaFileName = schemaName + ".xsd";
                resourceName =
                    (from string name in assembly.GetManifestResourceNames()
                     where name.EndsWith(schemaFileName)
                     select name).Single();
                xsdStream = Common.GetEmbeddedFile(assembly, resourceName);
                schemas.Add(fileIdentificationAssembler.ElementNamespace, XmlReader.Create(xsdStream));
            }

            // ProfileDefinition
            var soilProfileAssembler =
                new SoilProfileAssembler<SoilLayer1D, Soil>();
            assembly = soilProfileAssembler.GetType().Assembly;
            schemaName = Path.GetFileName(soilProfileAssembler.ElementNamespace);
            resourceName =
            (from string name in assembly.GetManifestResourceNames()
                where name.EndsWith(schemaName + ".xsd")
                select name).Single();
            xsdStream = Common.GetEmbeddedFile(assembly, resourceName);
            schemas.Add(soilProfileAssembler.ElementNamespace, XmlReader.Create(xsdStream));
            doc.Validate(schemas, (o, e) =>
            {
                result = false;
                errorMessage = e.Message;
            }, true);

            message = errorMessage;


            return result;
        }

        #endregion
    }
}