using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Extensions;
using Deltares.Standard.Language;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.Stability
{
    public class StabilityModelValidator : IRepairer
    {
        private const string GREATER_THAN_MAX = "GreaterThanMax";
        private const string LESS_THAN_MIN = "LessThanMin";
        private const string NOTINCREASING = "NotIncreasing"; // Note the difference!
        private const string NOT_INCREASING = "Not increasing"; // Note the difference!
        private const string CANNOT_BE_ZERO = "CannotBeZero";
        private const string NOT_ON_SURFACE = "Not on surface";
        private const string AT_SAME_POINT = "AtSamePoint";
        private const string SAME_START_AND_END_POINT = "Same Start and End Point";
        private const string NO_SOIL = "No soil";

        private readonly List<IValidationResult> forbiddenLineErrorList;
        private readonly List<IValidationResult> geoTextileErrorList;
        private readonly List<IValidationResult> lineLoadErrorList;
        private readonly StabilityModel model;
        private readonly List<IValidationResult> nailErrorList;
        private readonly PreConsolidationStressListValidator preConsolidationStressListValidator;
        private readonly List<IValidationResult> referenceLevelLineErrorList;
        private readonly List<IValidationResult> slipPlaneErrorList;
        private readonly List<IValidationResult> uniformLoadErrorList;

        public IValidationResult ErrorInputSlipCircle = new ValidationResult();
        public IValidationResult ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine = new ValidationResult();
        public IValidationResult ErrorInputSlipPlaneUpliftVanRightGrid = new ValidationResult();
        public IValidationResult ErrorInputTreeOnSlope = new ValidationResult();
        public IValidationResult HorizontalInputErrorInput = new ValidationResult();
        public IValidationResult ZoneAreasErrorInput = new ValidationResult();

        private string isOutsideGeometryX;
        private string isOutsideGeometryZ;

        public StabilityModelValidator(StabilityModel model)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }
            
            this.model = model;

            uniformLoadErrorList = new List<IValidationResult>();
            slipPlaneErrorList = new List<IValidationResult>();
            referenceLevelLineErrorList = new List<IValidationResult>();
            lineLoadErrorList = new List<IValidationResult>();
            nailErrorList = new List<IValidationResult>();
            geoTextileErrorList = new List<IValidationResult>();
            forbiddenLineErrorList = new List<IValidationResult>();
            preConsolidationStressListValidator = new PreConsolidationStressListValidator(model);
        }

        /// <summary>
        /// Gets the model to be validated.
        /// </summary>
        public StabilityModel Model
        {
            get
            {
                return model;
            }
        }

        public List<IValidationResult> ForbiddenLineErrorList
        {
            get
            {
                return forbiddenLineErrorList;
            }
        }

        public List<IValidationResult> GeoTextileErrorList
        {
            get
            {
                return geoTextileErrorList;
            }
        }

        public List<IValidationResult> SlipPlaneErrorList
        {
            get
            {
                return slipPlaneErrorList;
            }
        }

        public List<IValidationResult> LineLoadErrorList
        {
            get
            {
                return lineLoadErrorList;
            }
        }

        public List<IValidationResult> NailErrorList
        {
            get
            {
                return nailErrorList;
            }
        }

        public List<IValidationResult> UniformLoadErrorList
        {
            get
            {
                return uniformLoadErrorList;
            }
        }

        public List<IValidationResult> ReferenceLevelLineErrorList
        {
            get
            {
                return referenceLevelLineErrorList;
            }
        }

        public List<IValidationResult> GetErrorList(object sender)
        {
            var errorList = new List<IValidationResult>();
            if (sender != null)
            {
                switch (sender.GetType().ToString())
                {
                    case "Deltares.Stability.PressurePerLength":
                        {
                            return lineLoadErrorList;
                        }
                    case "Deltares.Stability.UniformLoad":
                        {
                            return uniformLoadErrorList;
                        }
                    case "Deltares.Stability.Geotextile":
                        {
                            return geoTextileErrorList;
                        }
                    case "Deltares.Stability.Nail":
                        {
                            return nailErrorList;
                        }
                    case "Deltares.Stability.ForbiddenLines":
                        {
                            return forbiddenLineErrorList;
                        }
                    case "Deltares.Geometry.GeometryPoint":
                        {
                            if (model.ReferenceLevelLine != null)
                            {
                                if (model.ReferenceLevelLine.Points.Contains(sender as GeometryPoint))
                                {
                                    return referenceLevelLineErrorList;
                                }
                            }
                            else if (model.SlipPlanes.Count > 0)
                            {
                                if (model.SlipPlanes[0].Points.Contains(sender as GeometryPoint))
                                {
                                    return SlipPlaneErrorList;
                                }
                                else if (model.SlipPlanes.Count > 1)
                                {
                                    if (model.SlipPlanes[1].Points.Contains(sender as GeometryPoint))
                                    {
                                        return SlipPlaneErrorList;
                                    }
                                }
                            }
                            break;
                        }
                    case "Deltares.Stability.SlipCircle":
                        {
                            errorList.Add(ErrorInputSlipCircle);
                            return errorList;
                        }
                    case "Deltares.Stability.HorizontalBalance":
                        {
                            errorList.Add(HorizontalInputErrorInput);
                            return errorList;
                        }
                    case "Deltares.Stability.SlipPlaneUpliftVan":
                    case "Deltares.Stability.SlipCircleGrid":
                        {
                            errorList.Add(ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine);
                            errorList.Add(ErrorInputSlipPlaneUpliftVanRightGrid);
                            return errorList;
                        }
                    case "Deltares.Stability.TreeOnSlope":
                        {
                            errorList.Add(ErrorInputTreeOnSlope);
                            return errorList;
                        }
                    case "Deltares.Stability.ZoneAreas":
                        {
                            errorList.Add(ZoneAreasErrorInput);
                            return errorList;
                        }
                }
            }
            return errorList;
        }

        public bool IsGeometryPointValid(GeometryPoint pointToBeValidated, string property)
        {
            if (!IsPointValid(referenceLevelLineErrorList, pointToBeValidated, property))
            {
                return false;
            }
            if (!IsPointValid(slipPlaneErrorList, pointToBeValidated, property))
            {
                return false;
            }
            if (!IsPointValid(geoTextileErrorList, pointToBeValidated, property))
            {
                return false;
            }
            if (!IsPointValid(forbiddenLineErrorList, pointToBeValidated, property))
            {
                return false;
            }
            return true;
        }

        public IValidationResult[] ValidateReferenceLevelLine()
        {
            var IValidationResultList = new List<IValidationResult>();

            if (model.ReferenceLevelLine != null)
            {
                string scope = "Reference level for ratio Cu/Pc";
                if (model.ReferenceLevelLine.Points.Count == 1)
                {
                    IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, scope + " data is invalid: Minimum two points are required to define reference level."));
                }
                else
                {
                    if (slipPlaneErrorList == null)
                    {
                        PopulateErrorList();
                    }

                    IValidationResultList.AddRange(PopulateValidationResult(referenceLevelLineErrorList, scope, "X"));
                    foreach (ValidationResult errorInput in referenceLevelLineErrorList.ToArray())
                    {
                        foreach (var property in errorInput.InvalidProperties)
                        {
                            if (property.Contains(AT_SAME_POINT))
                            {
                                IValidationResultList.Add(
                                    new ValidationResult(
                                        ValidationResultType.Error,
                                        ((GeometryPoint) errorInput.Subject).Description + " " + ((IGeometryObject) errorInput.Subject).Name + " values are similar to the previous points values",
                                        errorInput.Subject,
                                        "Geometry Point",
                                        SAME_START_AND_END_POINT,
                                        this));
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateHorizontalBalance()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (model.ModelOption == ModelOptions.HorizontalBalance)
            {
                if (model.HorizontalBalance != null)
                {
                    IValidationResultList.AddRange(Validator.Validate(model.HorizontalBalance));
                    PopulateErrorList();
                    if (HorizontalInputErrorInput.InvalidProperties != null)
                    {
                        foreach (var property in HorizontalInputErrorInput.InvalidProperties)
                        {
                            bool temp = property == "XLeft" || property == "XRight";
                            //foreach (InValidTypeEnum errorType in HorizontalInputErrorInput.InvalidProperties[property.Key])
                            {
                                IValidationResultList.Add(
                                    SetValidationResultText(
                                        HorizontalInputErrorInput.Subject,
                                        "Slip circle",
                                        property,
                                        temp,
                                        HorizontalInputErrorInput.ID[HorizontalInputErrorInput.InvalidProperties.IndexOf(property)]));
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateSlipPlane()
        {
            var validationResultList = new List<IValidationResult>();
            if (model.SoilProfile == null)
            {
                return validationResultList.ToArray();
            }

            if (model.ModelOption == ModelOptions.Spencer)
            {
                if (slipPlaneErrorList == null)
                {
                    PopulateErrorList();
                }

                if (slipPlaneErrorList == null)
                {
                    return validationResultList.ToArray();
                }

                var slipPlaneOutsideProfile = new List<SlipPlane>();

                foreach (ValidationResult errorInput in slipPlaneErrorList)
                {
                    foreach (var property in errorInput.InvalidProperties)
                    {
                        if (property.Contains(AT_SAME_POINT))
                        {
                            validationResultList.Add(
                                new ValidationResult(
                                    ValidationResultType.Error,
                                    ((GeometryPoint) errorInput.Subject).Description + " " + ((IGeometryObject) errorInput.Subject).Name + " values are similar to the previous points values",
                                    errorInput.Subject,
                                    "Geometry Point", SAME_START_AND_END_POINT,
                                    this));
                        }
                    }

                    // Check for points of the slip plane falling outside the profile
                    if (errorInput.ID.Contains(LESS_THAN_MIN) || errorInput.ID.Contains(GREATER_THAN_MAX))
                    {
                        var geometryPoint = errorInput.Subject as GeometryPoint;
                        if (geometryPoint != null)
                        {
                            slipPlaneOutsideProfile.Add((SlipPlane) geometryPoint.Owner);
                        }
                    }
                }

                // Check for validation warnings about slip planes falling outside the profile
                foreach (var slipPlane in slipPlaneOutsideProfile.Distinct())
                {
                    var text = LocalizationManager.GetTranslatedText(typeof(StabilityModelValidator), "SlipPlaneOutsideProfile");
                    var subject = slipPlane;
                    const string scope = "Slip planes";

                    validationResultList.Add(new ValidationResult(ValidationResultType.Warning, text, scope, subject));
                }

                // Check for validation warnings about slip planes start or end point not laying on the surface line
                foreach (var slipPlane in model.SlipPlanes)
                {
                    // Do not generate warning about start or end point if slip plane is already outside the profile
                    if (slipPlaneOutsideProfile.Contains(slipPlane))
                    {
                        continue;
                    }

                    if (slipPlane.Points.Count > 0)
                    {
                        var subject = slipPlane;
                        var text = LocalizationManager.GetTranslatedText(typeof(StabilityModelValidator), "SlipPlaneBeginPointNotOnSurface");
                        const string scope = "Slip planes";

                        var geometryPoint = slipPlane.Points[0];
                        if (Math.Round(model.GeometryData.GetSurfaceHeight(geometryPoint.X), 2) != Math.Round(geometryPoint.Z, 2))
                        {
                            validationResultList.Add(new ValidationResult(ValidationResultType.Warning, text, scope, subject));
                        }

                        text = LocalizationManager.GetTranslatedText(typeof(StabilityModelValidator), "SlipPlaneEndPointNotOnSurface");
                        geometryPoint = slipPlane.Points[slipPlane.Points.Count - 1];

                        if (Math.Round(model.GeometryData.GetSurfaceHeight(geometryPoint.X), 2) != Math.Round(geometryPoint.Z, 2))
                        {
                            validationResultList.Add(new ValidationResult(ValidationResultType.Warning, text, scope, subject));
                        }
                    }
                }
            }
            return validationResultList.ToArray();
        }

        public IValidationResult[] ValidateSpencer()
        {
            if (model.ModelOption == ModelOptions.Spencer)
            {
                if (model.SearchAlgorithm != SearchAlgorithm.Genetic && model.SlipPlanes.Count == 0)
                {
                    return new[]
                        {
                            new ValidationResult(ValidationResultType.Error, "No slip planes defined", model)
                        };
                }
                else if (model.SearchAlgorithm == SearchAlgorithm.Genetic && model.SlipPlanes.Count != 2)
                {
                    return new[]
                        {
                            new ValidationResult(ValidationResultType.Error, "Need 2 slip planes", model)
                        };
                }
                else if (model.SlipPlanes.Count == 2 && model.SlipPlanes[0].Points.Count != model.SlipPlanes[1].Points.Count)
                {
                    return new[]
                        {
                            new ValidationResult(ValidationResultType.Error, "Number of points in slip planes should be equal", model.SlipPlanes[0])
                        };
                }
            }

            return new ValidationResult[0];
        }

        public IValidationResult[] ValidateSlipPlaneUpliftVan()
        {
            var IValidationResultList = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.UpliftVan) || (model.ModelOption == ModelOptions.UpliftSpencer))
            {
                if (model.SlipPlaneUpliftVan != null && !model.IsUpliftVanSlipPlaneDefaultValues())
                {
                    PopulateErrorList();
                    if (ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.InvalidProperties != null)
                    {
                        foreach (var property in ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.InvalidProperties)
                        {
                            bool temp = property == "TangentLineXLeft" || property == "TangentLineXRight" || property == "GridXLeft" || property == "GridXRight";
                            //foreach (InValidTypeEnum errorType in ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.InvalidProperties[property.Key])
                            {
                                IValidationResultList.Add(SetValidationResultText(ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.Subject, "Slip plane", property, temp, ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.ID[ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.InvalidProperties.IndexOf(property)]));
                            }
                        }
                    }
                    if (ErrorInputSlipPlaneUpliftVanRightGrid.InvalidProperties != null)
                    {
                        foreach (var property in ErrorInputSlipPlaneUpliftVanRightGrid.InvalidProperties)
                        {
                            bool temp = property == "GridXLeft" || property == "GridXRight";
                            //foreach (InValidTypeEnum errorType in ErrorInputSlipPlaneUpliftVanRightGrid.InvalidProperties[property.Key])
                            {
                                IValidationResultList.Add(SetValidationResultText(ErrorInputSlipPlaneUpliftVanRightGrid.Subject, "Slip plane", property, temp, ErrorInputSlipPlaneUpliftVanRightGrid.ID[ErrorInputSlipPlaneUpliftVanRightGrid.InvalidProperties.IndexOf(property)]));
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateSlipCircle()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (IsBishopVariant())
            {
                if (model.SlipCircle != null && !model.IsSlipCircleDefaultValues())
                {
                    IValidationResultList.AddRange(Validator.Validate(model.SlipCircle.SlipCircleFixedPoint));
                    IValidationResultList.AddRange(Validator.Validate(model.SlipCircle.SlipCircleGrid));
                    IValidationResultList.AddRange(Validator.Validate(model.SlipCircle.SlipCircleTangentLine));
                    PopulateErrorList();
                    if (ErrorInputSlipCircle.InvalidProperties != null)
                    {
                        foreach (var property in ErrorInputSlipCircle.InvalidProperties)
                        {
                            bool temp = property == "XFixed";
                            //foreach (InValidTypeEnum errorType in ErrorInputSlipCircle.InvalidProperties[property.Key])
                            {
                                IValidationResultList.Add(SetValidationResultText(ErrorInputSlipCircle.Subject, "Slip circle", property, temp, ErrorInputSlipCircle.ID[ErrorInputSlipCircle.InvalidProperties.IndexOf(property)]));
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateDegreeofConsolidationEarthQuake()
        {
            var validationResultList = new List<IValidationResult>();
            if (model.ModelOption != ModelOptions.HorizontalBalance)
            {
                validationResultList.AddRange(Validator.Validate(model.ConsolidationMatrix.ConsolidationValues));
            }
            if (validationResultList.Count > 0)
            {
                validationResultList.Insert(0, new ValidationResult(ValidationResultType.Error, "Earthquake:"));
            }
            return validationResultList.ToArray();
        }

        public IValidationResult[] ValidateForbiddenLines()
        {
            var IValidationResultList = new List<IValidationResult>();
            PopulateErrorList();
            foreach (ValidationResult errorInput in forbiddenLineErrorList)
            {
                if (errorInput.InvalidProperties != null)
                {
                    if (errorInput.InvalidProperties.Count > 2 || (errorInput.InvalidProperties.Contains("StartX") && (errorInput.InvalidProperties.Contains("EndX") || errorInput.InvalidProperties.Contains("EndZ"))) || (errorInput.InvalidProperties.Contains("StartZ") && (errorInput.InvalidProperties.Contains("EndX") || errorInput.InvalidProperties.Contains("EndZ"))))
                    {
                        IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, ((ForbiddenLines) errorInput.Subject).Name + " is outside the Geometry limits",
                                                                       errorInput.Subject, "All", "Outside geometry limits", (IRepairer) this));
                    }
                    else if ((errorInput.InvalidProperties.Contains("StartX") && errorInput.InvalidProperties.Contains("StartZ")) || (errorInput.InvalidProperties.Contains("EndX") && errorInput.InvalidProperties.Contains("EndZ")))
                    {
                        GeometryPoint point = ((ForbiddenLines) errorInput.Subject).EndPoint;
                        if (errorInput.InvalidProperties.Contains("StartX") && errorInput.InvalidProperties.Contains("StartZ"))
                        {
                            point = ((ForbiddenLines) errorInput.Subject).StartPoint;
                        }
                        IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, "One of the point of " + ((ForbiddenLines) errorInput.Subject).Name + " is outside the geometry limits",
                                                                       point, "All", "Outside geometry limits", (IRepairer) this));
                    }
                    else
                    {
                        foreach (var property in errorInput.InvalidProperties)
                        {
                            bool temp = (property == "StartX" || property == "EndX") ? true : false;
                            //foreach (InValidTypeEnum errorType in errorInput.InvalidProperties[property.Key])
                            {
                                if (property == "Geometry Point")
                                {
                                    IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, "Start point and End point values are same",
                                                                                   errorInput.Subject, "Geometry Point", SAME_START_AND_END_POINT, this));
                                }
                                else
                                {
                                    IValidationResultList.Add(SetValidationResultText(errorInput.Subject, "Forbidden line", property, temp, errorInput.ID[errorInput.InvalidProperties.IndexOf(property)]));
                                }
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateGeotextile()
        {
            var IValidationResults = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan))
            {
                foreach (var geoTextile in model.Geotextiles)
                {
                    IValidationResults.AddRange(Validator.Validate(geoTextile));
                }
                PopulateErrorList();
                foreach (ValidationResult errorInput in geoTextileErrorList)
                {
                    if (errorInput.InvalidProperties != null)
                    {
                        bool isSamePoint = true;
                        if (errorInput.InvalidProperties.Count > 2)
                        {
                            foreach (var item in errorInput.InvalidProperties)
                            {
                                if (item == "Geometry Point")
                                {
                                    isSamePoint = false;
                                    break;
                                }
                            }
                        }
                        if ((errorInput.InvalidProperties.Count > 2 && isSamePoint) || (errorInput.InvalidProperties.Count > 3 && !isSamePoint) || (errorInput.InvalidProperties.Contains("StartX") && (errorInput.InvalidProperties.Contains("EndX") || errorInput.InvalidProperties.Contains("EndZ"))) || (errorInput.InvalidProperties.Contains("StartZ") && (errorInput.InvalidProperties.Contains("EndX") || errorInput.InvalidProperties.Contains("EndZ"))))
                        {
                            IValidationResults.Add(new ValidationResult(ValidationResultType.Error, ((Geotextile) errorInput.Subject).Name + " is outside the Geometry limits",
                                                                        errorInput.Subject, "All", "Outside geometry limits", (IRepairer) this));
                        }
                        else if ((errorInput.InvalidProperties.Contains("StartX") && errorInput.InvalidProperties.Contains("StartZ")) || (errorInput.InvalidProperties.Contains("EndX") && errorInput.InvalidProperties.Contains("EndZ")))
                        {
                            GeometryPoint point = ((Geotextile) errorInput.Subject).EndPoint;
                            if (errorInput.InvalidProperties.Contains("StartX") && errorInput.InvalidProperties.Contains("StartZ"))
                            {
                                point = ((Geotextile) errorInput.Subject).StartPoint;
                            }
                            IValidationResults.Add(new ValidationResult(ValidationResultType.Error, "One of the point of " + ((Geotextile) errorInput.Subject).Name + " is outside the geometry limits",
                                                                        point, "All", "Outside geometry limits", (IRepairer) this));
                        }
                        else
                        {
                            foreach (var property in errorInput.InvalidProperties)
                            {
                                bool temp = (property == "StartX" || property == "EndX") ? true : false;
                                //foreach (InValidTypeEnum errorType in errorInput.InvalidProperties[property.Key])
                                {
                                    if (property == "Geometry Point")
                                    {
                                        IValidationResults.Add(new ValidationResult(ValidationResultType.Error, "Start point and End point values are same",
                                                                                    errorInput.Subject, "Geometry Point", SAME_START_AND_END_POINT, this));
                                    }
                                    else
                                    {
                                        IValidationResults.Add(SetValidationResultText(errorInput.Subject, "Geotextile", property, temp, errorInput.ID[errorInput.InvalidProperties.IndexOf(property)]));
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return IValidationResults.ToArray();
        }

        public IValidationResult[] ValidateNails()
        {
            var IValidationResultList = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan))
            {
                foreach (var nail in model.Nails)
                {
                    IValidationResultList.AddRange(Validator.Validate(nail));
                }
                IValidationResultList.AddRange(PopulateValidationResult(nailErrorList, "Nail", "X"));
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateLineLoad()
        {
            var IValidationResultList = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan))
            {
                foreach (var lineLoad in model.LineLoads)
                {
                    IValidationResultList.AddRange(Validator.Validate(lineLoad));
                }
                IValidationResultList.AddRange(PopulateValidationResult(lineLoadErrorList, "Line Load", "X"));
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateUniformLoads()
        {
            var IValidationResultList = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Spencer) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan) || (model.ModelOption == ModelOptions.UpliftSpencer) || (model.ModelOption == ModelOptions.HorizontalBalance))
            {
                foreach (var uniformLoad in model.UniformLoads)
                {
                    IValidationResultList.AddRange(Validator.Validate(uniformLoad));
                }
                IValidationResultList.AddRange(PopulateValidationResult(uniformLoadErrorList, "Uniform Load", "XStart"));
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateTreeOnSlope()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius)) && model.TreeOnSlope != null && model.TreeOnSlope.WindForce != 0)
            {
                IValidationResultList.AddRange(Validator.Validate(model.TreeOnSlope));
                PopulateErrorList();
                if (ErrorInputTreeOnSlope.InvalidProperties != null)
                {
                    foreach (var property in ErrorInputTreeOnSlope.InvalidProperties)
                    {
                        bool temp = property == "X";
                        //foreach (InValidTypeEnum errorType in ErrorInputTreeOnSlope.InvalidProperties[property.Key])
                        {
                            IValidationResultList.Add(SetValidationResultText(ErrorInputTreeOnSlope.Subject, "Tree on slope", property, temp, ErrorInputTreeOnSlope.ID[ErrorInputTreeOnSlope.InvalidProperties.IndexOf(property)]));
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateEarthquake()
        {
            var IValidationResultList = new List<IValidationResult>();
            if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Spencer) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan) || (model.ModelOption == ModelOptions.UpliftSpencer) || (model.ModelOption == ModelOptions.BishopProbabilityRandomField))
            {
                if (model.Earthquake != null)
                {
                    IValidationResultList.AddRange(Validator.Validate(model.Earthquake));
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateProbabilisticDefaults()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (model.ProbabilisticDefaults != null)
            {
                IValidationResultList.AddRange(Validator.Validate(model.ProbabilisticDefaults));
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateSoilSurfaces()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (model.SoilProfile == null)
            {
                return IValidationResultList.ToArray();
            }

            if (model.SoilProfile.Surfaces.Count > 0 && model.GeometryData.IsAutomaticRegeneration == true)
            {
                foreach (var soilSurface in model.SoilProfile.Surfaces)
                {
                    if (soilSurface.Soil == null)
                    {
                        if (model.SoilModel.DefaultStabilitySoilMaterial != null)
                        {
                            IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, soilSurface.Name + " does not have soil",
                                                                           soilSurface, "SoilMaterial", NO_SOIL, (IRepairer) this));
                        }
                        else
                        {
                            IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, soilSurface.Name + " does not have soil", "Soil surface.", soilSurface));
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateProperties()
        {
            var IValidationResultList = new List<IValidationResult>();
            foreach (var prop in GetType().GetProperties())
            {
                if (prop.Name == "RequestedNumberOfSlices")
                {
                    IValidationResultList.AddRange(Validator.ValidateProperty(this, "RequestedNumberOfSlices", "Calculation options"));
                }
                if (prop.Name == "MinimalRequiredDepth")
                {
                    if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.UpliftVan) || (model.ModelOption == ModelOptions.BishopProbabilityRandomField))
                    {
                        IValidationResultList.AddRange(Validator.ValidateProperty(this, "MinimalRequiredDepth", "Calculation options"));
                    }
                }
                if (prop.Name == "StartValueSafetyFactor")
                {
                    if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.UpliftVan))
                    {
                        IValidationResultList.AddRange(Validator.ValidateProperty(this, "StartValueSafetyFactor", "Calculation options"));
                    }
                }
                if (prop.Name == "HalfSectionLength")
                {
                    if (model.IsEndSectionFrictionUsed)
                    {
                        if (model.ModelOption == ModelOptions.Bishop)
                        {
                            IValidationResultList.AddRange(Validator.ValidateProperty(this, "HalfSectionLength", "Calculation options"));
                        }
                    }
                }
            }

            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateZoneAreas()
        {
            var IValidationResultList = new List<IValidationResult>();
            if (model.SoilProfile == null)
            {
                return IValidationResultList.ToArray();
            }

            if (model.HasZonePlot)
            {
                if ((model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.UpliftVan) || (model.ModelOption == ModelOptions.UpliftSpencer))
                {
                    if (model.ZoneAreas != null)
                    {
                        IValidationResultList.AddRange(Validator.Validate(model.ZoneAreas));

                        PopulateErrorList();
                        if (ZoneAreasErrorInput.InvalidProperties != null)
                        {
                            foreach (var property in ZoneAreasErrorInput.InvalidProperties)
                            {
                                bool temp = false;
                                if (property == "DesignLevelInfluenceX" || property == "RestProfileStartX" || property == "LeftSideMinimalRoad")
                                {
                                    temp = true;
                                }
                                //foreach (InValidTypeEnum errorType in ZoneAreasErrorInput.InvalidProperties[property.Key])
                                {
                                    if (property == "DikeTableHeight")
                                    {
                                        IValidationResultList.Add(new ValidationResult(ValidationResultType.Error, "Zone Areas data is invalid: Diketable height is outside limits" + GetUserValue(model.GeometryData.MinGeometryPointsZ) + " to " + GetUserValue(model.GeometryData.MaxGeometryPointsZ + 20),
                                                                                       model.ZoneAreas, "DikeTableHeight", "Outside geometry", this));
                                    }
                                    else
                                    {
                                        IValidationResultList.Add(SetValidationResultText(ZoneAreasErrorInput.Subject, "Zone Areas", property, temp, ZoneAreasErrorInput.ID[ZoneAreasErrorInput.InvalidProperties.IndexOf(property)]));
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return IValidationResultList.ToArray();
        }

        public IValidationResult[] ValidateIntersectionCircleAndSurfaceLine()
        {
            var validationResultList = new List<IValidationResult>();
            if (model.SoilProfile == null || model.SoilProfile.Surfaces.Count == 0)
            {
                return validationResultList.ToArray();
            }

            if (model.SoilProfile != null && IsBishopVariant())
            {
                var minRadius = GetDistance(model.SlipCircle.SlipCircleGrid.GridXLeft,
                                            model.SlipCircle.SlipCircleGrid.GridZBottom, model.SlipCircle.SlipCircleGrid.GridXLeft,
                                            model.SlipCircle.SlipCircleTangentLine.TangentLineZBottom);

                var maxRadius = GetDistance(model.SlipCircle.SlipCircleGrid.GridXLeft,
                                            model.SlipCircle.SlipCircleGrid.GridZTop, model.SlipCircle.SlipCircleGrid.GridXLeft,
                                            model.SlipCircle.SlipCircleTangentLine.TangentLineZTop);

                if (model.SlipCircle.SlipCircleFixedPoint.UseFixedPoint)
                {
                    var leftDistance = GetDistance(model.SlipCircle.SlipCircleGrid.GridXLeft,
                                                   model.SlipCircle.SlipCircleGrid.GridZTop, model.SlipCircle.SlipCircleFixedPoint.XFixed,
                                                   model.SlipCircle.SlipCircleFixedPoint.ZFixed);

                    var rightDistance = GetDistance(model.SlipCircle.SlipCircleGrid.GridXRight,
                                                    model.SlipCircle.SlipCircleGrid.GridZTop, model.SlipCircle.SlipCircleFixedPoint.XFixed,
                                                    model.SlipCircle.SlipCircleFixedPoint.ZFixed);

                    var minDistance = Math.Min(leftDistance, rightDistance);
                    var maxDistance = Math.Max(leftDistance, rightDistance);

                    minRadius = Math.Min(minRadius, minDistance);
                    maxRadius = Math.Min(maxRadius, maxDistance);
                }

                var surfaceLine = model.GeometryData.SurfaceLine;

                if (
                    LineHelper.IntersectionPointsWithCircle(model.SlipCircle.SlipCircleGrid.GridXLeft,
                                                            model.SlipCircle.SlipCircleGrid.GridZTop, maxRadius, surfaceLine.Points).Count < 2 &&
                    LineHelper.IntersectionPointsWithCircle(model.SlipCircle.SlipCircleGrid.GridXRight,
                                                            model.SlipCircle.SlipCircleGrid.GridZTop, maxRadius, surfaceLine.Points).Count < 2 &&
                    LineHelper.IntersectionPointsWithCircle(model.SlipCircle.SlipCircleGrid.GridXLeft,
                                                            model.SlipCircle.SlipCircleGrid.GridZBottom, minRadius, surfaceLine.Points).Count < 2 &&
                    LineHelper.IntersectionPointsWithCircle(model.SlipCircle.SlipCircleGrid.GridXRight,
                                                            model.SlipCircle.SlipCircleGrid.GridZBottom, minRadius, surfaceLine.Points).Count < 2)
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Error,
                                                                  LocalizationManager.GetTranslatedText(model.SlipCircle.SlipCircleTangentLine,
                                                                                                        "Validation::NoIntersection")));
                }
            }

            if (model.SoilProfile != null && model.IsUpliftVan && model.SlipPlaneUpliftVan != null)
            {
                double tangLineZBottom;
                double tangLineZTop;
                if (model.SlipCircle.Auto == true)
                {
                    tangLineZBottom = model.SlipPlaneUpliftVan.SlipCircleTangentLine.BoundaryHeights.Max().Height;
                    tangLineZTop = model.SlipPlaneUpliftVan.SlipCircleTangentLine.BoundaryHeights.Min().Height;
                }
                else
                {
                    tangLineZBottom = model.SlipPlaneUpliftVan.SlipCircleTangentLine.TangentLineZBottom;
                    tangLineZTop = model.SlipPlaneUpliftVan.SlipCircleTangentLine.TangentLineZTop;
                }

                var minLeftRadius = GetDistance(model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZBottom, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                tangLineZBottom);

                var maxLeftRadius = GetDistance(model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZTop, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                tangLineZTop);

                var minRightRadius = GetDistance(model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                 model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZBottom, model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                 tangLineZBottom);

                var maxRightRadius = GetDistance(model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                 model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZTop, model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                 tangLineZTop);

                var surfaceLine = model.GeometryData.SurfaceLine;

                // Although Uplift Van requires only one intersection point per circle with the surface,
                // we check on tow intersection points, because we need the outer intersection point (i.e. 
                // an intersection point from which the x coordinate is smaller than the left circle centerpoint)
                // In that case there will be two intersection points, also the inner intersection point

                if ( //no left intersection
                    (LineHelper.IntersectionPointsWithCircle(model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                             model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZTop, maxLeftRadius, surfaceLine.Points).Count < 2 &&
                     LineHelper.IntersectionPointsWithCircle(model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft,
                                                             model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZBottom, minLeftRadius, surfaceLine.Points).Count < 2
                    )
                    ||
                    //no right intersection
                    (LineHelper.IntersectionPointsWithCircle(model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                             model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZTop, maxRightRadius, surfaceLine.Points).Count < 2 &&
                     LineHelper.IntersectionPointsWithCircle(model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight,
                                                             model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZBottom, minRightRadius, surfaceLine.Points).Count < 2))
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Error,
                                                                  LocalizationManager.GetTranslatedText(model.SlipCircle.SlipCircleTangentLine,
                                                                                                        "Validation::NoIntersection")));
                }
            }

            return validationResultList.ToArray();
        }

        public IValidationResult[] ValidateAllSlidingCurvesWithinSurfaceLine()
        {
            var validationResultList = new List<IValidationResult>();
            if (model.SoilProfile == null || model.SoilProfile.Surfaces.Count == 0)
            {
                return validationResultList.ToArray();
            }

            if (model.SoilProfile != null && IsBishopVariant())
            {
                var surfaceLine = model.GeometryData.SurfaceLine;

                double radius = Math.Abs(model.SlipCircle.SlipCircleGrid.GridZTop - model.SlipCircle.SlipCircleTangentLine.TangentLineZBottom);

                double xOffsetLeft = model.SlipCircle.SlipCircleGrid.GridXLeft - model.GeometryData.Left;
                double zOffsetLeft = model.SlipCircle.SlipCircleGrid.GridZTop - surfaceLine.GetZAtX(model.GeometryData.Left);

                if (radius*radius > xOffsetLeft*xOffsetLeft + zOffsetLeft*zOffsetLeft)
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Warning, LocalizationManager.GetTranslatedText(GetType(), "NoIntersectionForAllSlidingPlanes")));
                }

                double xOffsetRight = model.SlipCircle.SlipCircleGrid.GridXRight - model.GeometryData.Right;
                double zOffsetRight = model.SlipCircle.SlipCircleGrid.GridZTop - surfaceLine.GetZAtX(model.GeometryData.Right);

                if (radius*radius > xOffsetRight*xOffsetRight + zOffsetRight*zOffsetRight)
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Warning, LocalizationManager.GetTranslatedText(GetType(), "NoIntersectionForAllSlidingPlanes")));
                }
            }

            if (model.SoilProfile != null && model.IsUpliftVan && model.SlipPlaneUpliftVan != null)
            {
                var surfaceLine = model.GeometryData.SurfaceLine;

                double radius = Math.Abs(model.SlipCircle.SlipCircleGrid.GridZTop - model.SlipPlaneUpliftVan.SlipCircleTangentLine.TangentLineZBottom);

                double xOffsetLeft = model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft - model.GeometryData.Left;
                double zOffsetLeft = model.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZTop - surfaceLine.GetZAtX(model.GeometryData.Left);

                if (radius*radius > xOffsetLeft*xOffsetLeft + zOffsetLeft*zOffsetLeft)
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Warning, LocalizationManager.GetTranslatedText(GetType(), "NoIntersectionForAllSlidingPlanes")));
                }

                double xOffsetRight = model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight - model.GeometryData.Right;
                double zOffsetRight = model.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZTop - surfaceLine.GetZAtX(model.GeometryData.Right);

                if (radius*radius > xOffsetRight*xOffsetRight + zOffsetRight*zOffsetRight)
                {
                    validationResultList.Add(new ValidationResult(ValidationResultType.Warning, LocalizationManager.GetTranslatedText(GetType(), "NoIntersectionForAllSlidingPlanes")));
                }
            }

            return validationResultList.ToArray();
        }

        public IValidationResult[] ValidateTangentLine()
        {
            var validationResultList = new List<IValidationResult>();

            if (IsBishopVariant())
            {
                validationResultList.AddRange(GetTangentLineValidationErrors(model.SlipCircle.SlipCircleTangentLine));
            }
            else if (model.IsUpliftVan)
            {
                validationResultList.AddRange(GetTangentLineValidationErrors(model.SlipPlaneUpliftVan.SlipCircleTangentLine));
            }

            return validationResultList.ToArray();
        }

        /// <summary>
        /// Validates the data in <see cref="StabilityModel.PreConsolidationStressList"/>.
        /// </summary>
        /// <returns>The collection of validation messages generated by this method.</returns>
        public IValidationResult[] ValidatePreconsolidationStresses()
        {
            return preConsolidationStressListValidator.Validate();
        }

        public IValidationResult[] ValidateAquifer()
        {
            var validationResultList = new List<IValidationResult>();

            if (!model.SoilProfile.Surfaces.Any(p => p.IsAquifer))
            {
                validationResultList.Add(new ValidationResult(ValidationResultType.Error, LocalizationManager.GetTranslatedText(GetType(), "NoAquiferLayer")));
            }

            return validationResultList.ToArray();
        }


        private IValidationResult SetValidationResultText(object inValidObject, string scope, string property, bool isHorizontal, string invalidType)
        {
            var validationResult = new ValidationResult(ValidationResultType.Error, invalidType, inValidObject, property, invalidType, (IRepairer) this);
            switch (invalidType)
            {
                case LESS_THAN_MIN:
                case GREATER_THAN_MAX:
                    validationResult.AddPropertyAndID(property, invalidType);
                    var invalidTypeString = isHorizontal ? isOutsideGeometryX : isOutsideGeometryZ;

                    if (inValidObject.GetType() == typeof(GeometryPoint))
                    {
                        var owner = ((GeometryPoint) inValidObject).Owner;
                        var name = owner.ToString().ToLower();
                        validationResult.Text = string.Format("{0} {1} data is invalid : {2} {3}.", "GeometryPoint", name, property, invalidTypeString);
                        validationResult.MessageType = ValidationResultType.Warning;
                        validationResult.Subject = ((GeometryPoint) inValidObject).Owner;
                    }
                    else
                    {
                        if (inValidObject is IGeometryObject)
                        {
                            validationResult.Text = ((IGeometryObject) inValidObject).Name + " data is invalid : " + property + " " + invalidTypeString;
                        }
                        else
                        {
                            validationResult.Text = inValidObject + " data is invalid : " + property + " " + invalidTypeString;
                        }
                    }
                    break;
                case NOTINCREASING:
                    validationResult.AddPropertyAndID(property, NOTINCREASING);
                    validationResult.Text = ((GeometryPoint) inValidObject).Description + " " + ((IGeometryObject) inValidObject).Name + " data is invalid : " + property + " value not in increasing order";
                    break;
                case CANNOT_BE_ZERO:
                    validationResult.AddPropertyAndID(property, CANNOT_BE_ZERO);
                    validationResult.Text = string.Format("{0} data is invalid : {1} value cannot be zero", ((IGeometryObject) inValidObject).Name, property);
                    break;
                case NOT_ON_SURFACE:
                    validationResult.AddPropertyAndID(property, NOT_ON_SURFACE);
                    validationResult.Text = string.Format("{0} data is invalid : {1} is not on the surface", ((IGeometryObject) inValidObject).Name, property);
                    break;
            }
            return validationResult;
        }

        private IEnumerable<IValidationResult> PopulateValidationResult(IEnumerable<IValidationResult> errorInputList, string scope, string propertyKey)
        {
            var validationResultList = new List<IValidationResult>();
            PopulateErrorList();

            foreach (ValidationResult errorInput in errorInputList.ToArray())
            {
                foreach (var property in errorInput.InvalidProperties)
                {
                    bool temp = (property == propertyKey);
                    int index = errorInput.InvalidProperties.IndexOf(property);

                    switch (errorInput.ID[index])
                    {
                        case LESS_THAN_MIN:
                        case GREATER_THAN_MAX:
                            validationResultList.Add(SetValidationResultText(errorInput.Subject, scope, property, temp, errorInput.ID[index]));
                            break;
                        case NOTINCREASING:
                            validationResultList.Add(SetValidationResultText(errorInput.Subject, scope, property, temp, errorInput.ID[index]));
                            break;
                        case CANNOT_BE_ZERO:
                            validationResultList.Add(SetValidationResultText(errorInput.Subject, scope, property, temp, errorInput.ID[index]));
                            break;
                        case NOT_ON_SURFACE:
                            validationResultList.Add(SetValidationResultText(errorInput.Subject, scope, property, temp, errorInput.ID[index]));
                            break;
                    }
                }
            }
            return validationResultList;
        }

        private IEnumerable<IValidationResult> GetTangentLineValidationErrors(SlipCircleTangentLine slipCircleTangentLine)
        {
            if (slipCircleTangentLine.TangentLineNumber == 1 &&
                !slipCircleTangentLine.TangentLineZTop.AlmostEquals(
                    slipCircleTangentLine.TangentLineZBottom))
            {
                yield return new ValidationResult(ValidationResultType.Error,
                                                  LocalizationManager.GetTranslatedText(slipCircleTangentLine,
                                                                                        "Validation::TangentLineNotValid"));
            }
            if (slipCircleTangentLine.TangentLineZTop <
                slipCircleTangentLine.TangentLineZBottom)
            {
                yield return new ValidationResult(ValidationResultType.Error,
                                                  LocalizationManager.GetTranslatedText(slipCircleTangentLine,
                                                                                        "Validation::TangentLineBottomHigherThanTop"));
            }
            if (slipCircleTangentLine.TangentLineNumber == 0 &&
                (model.SlipCircle.SlipCircleFixedPoint == null ||
                 !model.SlipCircle.SlipCircleFixedPoint.UseFixedPoint))
            {
                yield return new ValidationResult(ValidationResultType.Error,
                                                  LocalizationManager.GetTranslatedText(slipCircleTangentLine,
                                                                                        "Validation::NoTangentLineNoFixedPoint"));
            }
        }

        private string GetUserValue(double value)
        {
            string unitLabelContent = UnitsManager.GetUserUnitString(UnitType.Length);
            return Math.Round(UnitsManager.GetUserValue(UnitType.Length, value), 3).ToString() + " " + unitLabelContent;
        }

        private void PopulateErrorList()
        {
            forbiddenLineErrorList.Clear();
            geoTextileErrorList.Clear();
            slipPlaneErrorList.Clear();
            lineLoadErrorList.Clear();
            nailErrorList.Clear();
            uniformLoadErrorList.Clear();
            referenceLevelLineErrorList.Clear();

            ZoneAreasErrorInput.ClearValidationResult();
            ErrorInputSlipCircle.ClearValidationResult();
            ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine.ClearValidationResult();
            ErrorInputSlipPlaneUpliftVanRightGrid.ClearValidationResult();
            ErrorInputTreeOnSlope.ClearValidationResult();

            if (model.SoilProfile == null)
            {
                return;
            }

            isOutsideGeometryX = " is outside geometry limits (" + GetUserValue(model.GeometryData.MinGeometryPointsX) + " to " + GetUserValue(model.GeometryData.MaxGeometryPointsX) + " )";
            isOutsideGeometryZ = " is outside geometry limits (" + GetUserValue(model.GeometryData.MinGeometryPointsZ) + " to " + GetUserValue(model.GeometryData.MaxGeometryPointsZ) + " )";
            var maxZGeometry = model.GeometryData.MaxGeometryPointsZ;
            foreach (var forbiddenLine in model.ForbiddenLinesList)
            {
                forbiddenLineErrorList.Add(GetInvalidProperties(forbiddenLine, maxZGeometry));
            }
            foreach (var geoTextile in model.Geotextiles)
            {
                geoTextileErrorList.Add(GetInvalidProperties(geoTextile, maxZGeometry));
            }
            foreach (var slipPlane in model.SlipPlanes)
            {
                foreach (var point in slipPlane.Points)
                {
                    slipPlaneErrorList.Add(GetInvalidProperties(point, maxZGeometry));
                }
            }
            if (model.ReferenceLevelLine != null)
            {
                foreach (var point in model.ReferenceLevelLine.Points)
                {
                    referenceLevelLineErrorList.Add(GetInvalidProperties(point, maxZGeometry));
                }
            }
            foreach (var lineLoad in model.LineLoads)
            {
                lineLoadErrorList.Add(GetInvalidProperties(lineLoad, maxZGeometry));
            }
            foreach (var nail in model.Nails)
            {
                nailErrorList.Add(GetInvalidProperties(nail, maxZGeometry));
            }
            foreach (var uniformLoad in model.UniformLoads)
            {
                uniformLoadErrorList.Add(GetInvalidProperties(uniformLoad, maxZGeometry));
            }
            if (model.SlipCircle != null)
            {
                ErrorInputSlipCircle = GetInvalidProperties(model.SlipCircle, maxZGeometry);
            }
            if (model.HorizontalBalance != null)
            {
                HorizontalInputErrorInput = GetInvalidProperties(model.HorizontalBalance, maxZGeometry);
            }
            if (model.SlipPlaneUpliftVan != null)
            {
                ErrorInputSlipPlaneUpliftVanLeftGridAndTangentLine = GetInvalidProperties(model.SlipPlaneUpliftVan, 10000000);
                ErrorInputSlipPlaneUpliftVanRightGrid = GetInvalidProperties(model.SlipPlaneUpliftVan.SlipPlaneRightGrid, 10000000);
            }
            if (model.TreeOnSlope != null)
            {
                ErrorInputTreeOnSlope = GetInvalidProperties(model.TreeOnSlope, 10000000);
            }
            if (model.ZoneAreas != null)
            {
                ZoneAreasErrorInput = GetInvalidProperties(model.ZoneAreas, maxZGeometry);
            }
        }

        private IValidationResult GetInvalidProperties(object objectToBeValidated, double zMax)
        {
            var err = new ValidationResult();
            err.Repairer = this;

            if (objectToBeValidated != null)
            {
                switch (objectToBeValidated.GetType().ToString())
                {
                    case "Deltares.Stability.PressurePerLength":
                        {
                            var lineLoad = objectToBeValidated as LineLoad;
                            WriteInvalidPropertiesOutsideGeometry(ref err, lineLoad, "X", true, zMax);
                            break;
                        }
                    case "Deltares.Stability.UniformLoad":
                        {
                            var uniformLoad = objectToBeValidated as UniformLoad;
                            WriteInvalidPropertiesOutsideGeometry(ref err, uniformLoad, "XStart", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, uniformLoad, "XEnd", true, zMax);
                            break;
                        }
                    case "Deltares.Stability.Nail":
                        {
                            var nail = objectToBeValidated as Nail;
                            if (nail != null)
                            {
                                WriteInvalidPropertiesOutsideGeometry(ref err, nail, "X", true, zMax);
                                if (nail.Length < 0.001)
                                {
                                    err.AddPropertyAndID("Length", CANNOT_BE_ZERO);
                                }

                                if (model.GeometryData.Surfaces.Count > 0)
                                {
                                    // Do this check only if there is a surface.
                                    if (Math.Abs(model.GeometryData.GetSurfaceHeight(nail.NailHeadPoint.X) - nail.NailHeadPoint.Z) > 0.001)
                                    {
                                        err.AddPropertyAndID("NailHeadPoint", NOT_ON_SURFACE);
                                    }
                                }
                            }
                            break;
                        }
                    case "Deltares.Stability.Geotextile":
                        {
                            var geotextile = objectToBeValidated as Geotextile;
                            WriteInvalidPropertiesOutsideGeometry(ref err, geotextile, "StartX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, geotextile, "EndX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, geotextile, "StartZ", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, geotextile, "EndZ", false, zMax);
                            if (Math.Abs(geotextile.StartX - geotextile.EndX) < 0.0001 && Math.Abs(geotextile.StartZ - geotextile.EndZ) < 0.0001)
                            {
                                err.AddPropertyAndID("GeometryPoint", AT_SAME_POINT);
                            }
                            break;
                        }
                    case "Deltares.Stability.ForbiddenLines":
                        {
                            var forbiddenLine = objectToBeValidated as ForbiddenLines;
                            WriteInvalidPropertiesOutsideGeometry(ref err, forbiddenLine, "StartX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, forbiddenLine, "EndX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, forbiddenLine, "StartZ", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, forbiddenLine, "EndZ", false, zMax);
                            if (Math.Abs(forbiddenLine.StartX - forbiddenLine.EndX) < 0.0001 && Math.Abs(forbiddenLine.StartZ - forbiddenLine.EndZ) < 0.0001)
                            {
                                err.AddPropertyAndID("GeometryPoint", AT_SAME_POINT);
                            }
                            break;
                        }
                    case "Deltares.Geometry.GeometryPoint":
                        {
                            var point = objectToBeValidated as GeometryPoint;

                            #region ReferenceLevelLine

                            if (model.ReferenceLevelLine != null)
                            {
                                if (model.ReferenceLevelLine.Points.Contains(point))
                                {
                                    int pointIndex = model.ReferenceLevelLine.Points.IndexOf(point);
                                    if (OutsideGeometryAlone(point, "X", true, zMax) != "UnKnown") //X Outside Geometry
                                    {
                                        if (OutsideGeometryAlone(point, "X", true, zMax) == LESS_THAN_MIN)
                                        {
                                            err.AddPropertyAndID("X", LESS_THAN_MIN);
                                        }
                                        else
                                        {
                                            err.AddPropertyAndID("X", GREATER_THAN_MAX);
                                        }
                                    }
                                    if (pointIndex > 0) // Not increasing
                                    {
                                        if (model.ReferenceLevelLine.Points[pointIndex - 1].X > point.X)
                                        {
                                            err.AddPropertyAndID("X", NOTINCREASING);
                                        }
                                        else if (Math.Abs(model.ReferenceLevelLine.Points[pointIndex - 1].X - point.X) < 0.0001 && Math.Abs(model.ReferenceLevelLine.Points[pointIndex - 1].Z - point.Z) < 0.0001)
                                        {
                                            err.AddPropertyAndID("X", AT_SAME_POINT);
                                        }
                                    }

                                    WriteInvalidPropertiesOutsideGeometry(ref err, point, "Z", false, zMax);
                                }
                            }

                            #endregion

                            #region Slip plane

                            if (model.SlipPlanes.Count > 0)
                            {
                                int pointIndex = -1;
                                int slipPlaneIndex = -1;
                                bool isContains = false;
                                if (model.SlipPlanes[0].Points.Contains(point))
                                {
                                    pointIndex = model.SlipPlanes[0].Points.IndexOf(point);
                                    slipPlaneIndex = 0;
                                    isContains = true;
                                }
                                else if (model.SlipPlanes.Count == 2)
                                {
                                    if (model.SlipPlanes[1].Points.Contains(point))
                                    {
                                        pointIndex = model.SlipPlanes[1].Points.IndexOf(point);
                                        slipPlaneIndex = 1;
                                        isContains = true;
                                    }
                                }
                                if (isContains)
                                {
                                    if (OutsideGeometryAlone(point, "X", true, zMax) != "UnKnown") //X Outside Geometry
                                    {
                                        if (OutsideGeometryAlone(point, "X", true, zMax) == LESS_THAN_MIN)
                                        {
                                            err.AddPropertyAndID("X", LESS_THAN_MIN);
                                        }
                                        else
                                        {
                                            err.AddPropertyAndID("X", GREATER_THAN_MAX);
                                        }
                                    }
                                    if (pointIndex > 0) //Not increasing
                                    {
                                        if (model.SlipPlanes[slipPlaneIndex].Points[pointIndex - 1].X > point.X)
                                        {
                                            err.AddPropertyAndID("X", NOTINCREASING);
                                        }
                                        else if (Math.Abs(model.SlipPlanes[slipPlaneIndex].Points[pointIndex - 1].X - point.X) < 0.0001 && Math.Abs(model.SlipPlanes[slipPlaneIndex].Points[pointIndex - 1].Z - point.Z) < 0.0001)
                                        {
                                            err.AddPropertyAndID("X", AT_SAME_POINT);
                                        }
                                    }

                                    WriteInvalidPropertiesOutsideGeometry(ref err, point, "Z", false, zMax);
                                }
                            }

                            #endregion

                            break;
                        }
                    case "Deltares.Stability.SlipCircle":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipCircle.SlipCircleTangentLine, "TangentLineZTop", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipCircle.SlipCircleTangentLine, "TangentLineZBottom", false, zMax);

                            if (model.SlipCircle.SlipCircleFixedPoint.UseFixedPoint == true)
                            {
                                WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipCircle.SlipCircleFixedPoint, "XFixed", true, zMax);
                                WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipCircle.SlipCircleFixedPoint, "ZFixed", false, zMax);
                            }
                            break;
                        }
                    case "Deltares.Stability.HorizontalBalance":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.HorizontalBalance, "XLeft", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.HorizontalBalance, "XRight", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.HorizontalBalance, "ZBottom", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.HorizontalBalance, "ZTop", false, zMax);
                            break;
                        }
                    case "Deltares.Stability.SlipPlaneUpliftVan":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid, "GridXLeft", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid, "GridXRight", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid, "GridZTop", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneLeftGrid, "GridZBottom", false, zMax);

                            if (model.SlipPlaneUpliftVan.SlipPlaneTangentLine.AutomaticAtBoundaries)
                            {
                                WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneTangentLine, "TangentLineZTop", false, zMax);
                                WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneTangentLine, "TangentLineZBottom", false, zMax);
                            }
                            break;
                        }
                    case "Deltares.Stability.SlipCircleGrid":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneRightGrid, "GridXLeft", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneRightGrid, "GridXRight", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneRightGrid, "GridZTop", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.SlipPlaneUpliftVan.SlipPlaneRightGrid, "GridZBottom", false, zMax);
                            break;
                        }
                    case "Deltares.Stability.TreeOnSlope":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.TreeOnSlope, "X", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.TreeOnSlope, "Z", false, zMax);
                            break;
                        }
                    case "Deltares.Stability.ZoneAreas":
                        {
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "DikeTableHeight", false, zMax); // + 20
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "RestProfileStartX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "DesignLevelInfluenceX", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "DesignLevelInfluenceY", false, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "LeftSideMinimalRoad", true, zMax);
                            WriteInvalidPropertiesOutsideGeometry(ref err, model.ZoneAreas, "RightSideMinimalRoad", true, zMax);
                            break;
                        }
                }
            }
            err.Subject = objectToBeValidated;
            return err;
        }

        private void WriteInvalidPropertiesOutsideGeometry(ref ValidationResult dict, object objectToBeValidated, string proeprty, bool isHorizontal,
            double zMax)
        {
            if (OutsideGeometryAlone(objectToBeValidated, proeprty, isHorizontal, zMax) != "UnKnown")
            {
                if (OutsideGeometryAlone(objectToBeValidated, proeprty, isHorizontal, zMax) == LESS_THAN_MIN)
                {
                    dict.AddPropertyAndID(proeprty, LESS_THAN_MIN);
                }
                else
                {
                    dict.AddPropertyAndID(proeprty, GREATER_THAN_MAX);
                }
            }
        }

        private string OutsideGeometryAlone(object objectTobeValidated, string property, bool isMinMaxHorizontal, double zMax)
        {
            if (model.GeometryData.Surfaces.Count > 0)
            {
                double value = Convert.ToDouble(objectTobeValidated.GetType().GetProperty(property).GetValue(objectTobeValidated, null));
                if (isMinMaxHorizontal)
                {
                    if (value < model.GeometryData.MinGeometryPointsX)
                    {
                        return LESS_THAN_MIN;
                    }
                    else if (value > model.GeometryData.MaxGeometryPointsX)
                    {
                        return GREATER_THAN_MAX;
                    }
                }
                else
                {
                    if (value < model.GeometryData.MinGeometryPointsZ)
                    {
                        return LESS_THAN_MIN;
                    }
                    else if (value > zMax)
                    {
                        return GREATER_THAN_MAX;
                    }
                }
            }
            return "UnKnown";
        }

        private static bool IsPointValid(IEnumerable<IValidationResult> errorList, GeometryPoint pointToBeValidated, string property)
        {
            foreach (ValidationResult errorItem in errorList)
            {
                if (errorItem.Subject == pointToBeValidated)
                {
                    foreach (var item in errorItem.InvalidProperties)
                    {
                        if (item == property)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

        /// <summary>
        /// Sets the values of Forbidden lines properties to min and max
        /// </summary>
        /// <param name="isX">If true changes X else the Z coordinates</param>
        /// <param name="forbiddenLine">The forbidden line object to be repaired.</param>
        private void SetMinMaxToForbiddenLine(bool isX, ForbiddenLines forbiddenLine)
        {
            if (isX)
            {
                if (forbiddenLine.StartX < forbiddenLine.EndX)
                {
                    forbiddenLine.StartX = model.GeometryData.MinGeometryPointsX;
                    forbiddenLine.EndX = model.GeometryData.MaxGeometryPointsX;
                }
                else
                {
                    forbiddenLine.StartX = model.GeometryData.MaxGeometryPointsX;
                    forbiddenLine.EndX = model.GeometryData.MinGeometryPointsX;
                }
            }
            else
            {
                if (forbiddenLine.StartZ < forbiddenLine.EndZ)
                {
                    forbiddenLine.StartZ = model.GeometryData.MinGeometryPointsZ;
                    forbiddenLine.EndZ = model.GeometryData.MaxGeometryPointsZ;
                }
                else
                {
                    forbiddenLine.StartZ = model.GeometryData.MaxGeometryPointsZ;
                    forbiddenLine.EndZ = model.GeometryData.MinGeometryPointsZ;
                }
            }
        }

        /// <summary>
        /// Sets the values of geotextile properties to min and max
        /// </summary>
        /// <param name="isX">If true changes X else the Z coordinates</param>
        /// <param name="forbiddenLine">The Geotextile line object to be repaired.</param>
        private void SetMinMaxToGeotextile(bool isX, Geotextile geotextile)
        {
            if (isX)
            {
                if (geotextile.StartX < geotextile.EndX)
                {
                    geotextile.StartX = model.GeometryData.MinGeometryPointsX;
                    geotextile.EndX = model.GeometryData.MaxGeometryPointsX;
                }
                else
                {
                    geotextile.StartX = model.GeometryData.MaxGeometryPointsX;
                    geotextile.EndX = model.GeometryData.MinGeometryPointsX;
                }
            }
            else
            {
                if (geotextile.StartZ < geotextile.EndZ)
                {
                    geotextile.StartZ = model.GeometryData.MinGeometryPointsZ;
                    geotextile.EndZ = model.GeometryData.MaxGeometryPointsZ;
                }
                else
                {
                    geotextile.StartZ = model.GeometryData.MaxGeometryPointsZ;
                    geotextile.EndZ = model.GeometryData.MinGeometryPointsZ;
                }
            }
        }

        /// <summary>
        /// Sets the min and max to geom point if the value is outside the geometry
        /// </summary>
        /// <param name="isValueX">Changes X coord if true else Z coord</param>
        /// <param name="geomPoint">The Geometry Point whose cord are to be changed</param>
        private void SetValueOfPoint(bool isValueX, GeometryPoint geomPoint)
        {
            if (isValueX)
            {
                if (geomPoint.X < model.GeometryData.MinGeometryPointsX)
                {
                    geomPoint.X = model.GeometryData.MinGeometryPointsX;
                }
                else
                {
                    geomPoint.X = model.GeometryData.MaxGeometryPointsX;
                }
            }
            else
            {
                if (geomPoint.Z < model.GeometryData.MinGeometryPointsZ)
                {
                    geomPoint.Z = model.GeometryData.MinGeometryPointsZ;
                }
                else
                {
                    geomPoint.Z = model.GeometryData.MaxGeometryPointsZ;
                }
            }
        }

        private double GetDistance(double x1, double y1, double x2, double y2)
        {
            return Math.Sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
        }

        private bool IsBishopVariant()
        {
            return (model.ModelOption == ModelOptions.Bishop) || (model.ModelOption == ModelOptions.Fellenius) || (model.ModelOption == ModelOptions.BishopProbabilityRandomField);
        }

        #region IRepairer Members

        /// <summary>
        /// Repairs the objects related to this model
        /// </summary>
        /// <param name="subject">The object to be repaired</param>
        /// <param name="property">The property of the object which has to be repaired</param>
        /// <param name="id">The error type</param>
        public void Repair(object subject, string property, string id)
        {
            try
            {
                if ((id == "Outside geometry limits") || (id == LESS_THAN_MIN) || (id == GREATER_THAN_MAX))
                {
                    if (subject.GetType() == typeof(LineLoad))
                    {
                        SetValueOfPoint(true, ((LineLoad) subject).LineLoadPoint);
                    }
                    else if (subject.GetType() == typeof(UniformLoad))
                    {
                        if (property == "XStart")
                        {
                            ((UniformLoad)subject).XStart = (((UniformLoad)subject).XStart > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "XEnd")
                        {
                            ((UniformLoad)subject).XEnd = (((UniformLoad)subject).XEnd > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                    }
                    else if (subject.GetType() == typeof(Geotextile))
                    {
                        if (property == "All")
                        {
                            #region Init

                            double XToBeMoved = 0.00;
                            double ZToBeMoved = 0.00;
                            double XEndToBeMoved = 0.00;
                            double ZEndToBeMoved = 0.00;
                            double GeotextileWidth = 0.00;
                            double GeotextileHeight = 0.00;
                            double GeometryWidth = 0.00;
                            double GeometryHeight = 0.00;

                            bool isStartXLessThanMin = false;
                            bool isStartXGreaterThanMax = false;
                            bool isStartZLessThanMin = false;
                            bool isStartZGreaterThanMax = false;
                            bool isEndXLessThanMin = false;
                            bool isEndXGreaterThanMax = false;
                            bool isEndZLessThanMin = false;
                            bool isEndZGreaterThanMax = false;

                            var repairedGeotextile = (Geotextile) subject;
                            GeotextileWidth = Math.Abs(repairedGeotextile.EndX - repairedGeotextile.StartX);
                            GeotextileHeight = Math.Abs(repairedGeotextile.EndZ - repairedGeotextile.StartZ);
                            GeometryWidth = Math.Abs(model.GeometryData.MaxGeometryPointsX - model.GeometryData.MinGeometryPointsX);
                            GeometryHeight = Math.Abs(model.GeometryData.MaxGeometryPointsZ - model.GeometryData.MinGeometryPointsZ);

                            #endregion

                            #region Find difference From End Point to Geometry

                            if (repairedGeotextile.EndX > model.GeometryData.MaxGeometryPointsX)
                            {
                                isEndXGreaterThanMax = true;
                                XEndToBeMoved = repairedGeotextile.EndX - model.GeometryData.MaxGeometryPointsX;
                            }
                            else if (repairedGeotextile.EndX < model.GeometryData.MinGeometryPointsX)
                            {
                                isEndXLessThanMin = true;
                                XEndToBeMoved = model.GeometryData.MinGeometryPointsX - repairedGeotextile.EndX;
                            }
                            if (repairedGeotextile.EndZ > model.GeometryData.MaxGeometryPointsZ)
                            {
                                isEndZGreaterThanMax = true;
                                ZEndToBeMoved = repairedGeotextile.EndZ - model.GeometryData.MaxGeometryPointsZ;
                            }
                            else if (repairedGeotextile.EndZ < model.GeometryData.MinGeometryPointsZ)
                            {
                                isEndZLessThanMin = true;
                                ZEndToBeMoved = model.GeometryData.MinGeometryPointsZ - repairedGeotextile.EndZ;
                            }

                            #endregion

                            #region Find difference From Start Point to Geometry

                            if (repairedGeotextile.StartX > model.GeometryData.MaxGeometryPointsX)
                            {
                                isStartXGreaterThanMax = true;
                                XToBeMoved = repairedGeotextile.StartX - model.GeometryData.MaxGeometryPointsX;
                            }
                            else if (repairedGeotextile.StartX < model.GeometryData.MinGeometryPointsX)
                            {
                                isStartXLessThanMin = true;
                                XToBeMoved = model.GeometryData.MinGeometryPointsX - repairedGeotextile.StartX;
                            }
                            if (repairedGeotextile.StartZ > model.GeometryData.MaxGeometryPointsZ)
                            {
                                isStartZGreaterThanMax = true;
                                ZToBeMoved = repairedGeotextile.StartZ - model.GeometryData.MaxGeometryPointsZ;
                            }
                            else if (repairedGeotextile.StartZ < model.GeometryData.MinGeometryPointsZ)
                            {
                                isStartZLessThanMin = true;
                                ZToBeMoved = model.GeometryData.MinGeometryPointsZ - repairedGeotextile.StartZ;
                            }

                            #endregion

                            #region X Repair

                            //Geotextile is outside the geometry in left and right sides.
                            if ((isStartXLessThanMin && isEndXGreaterThanMax) || (isStartXGreaterThanMax && isEndXLessThanMin))
                            {
                                SetMinMaxToGeotextile(true, repairedGeotextile);
                            }

                            //Geotextile is Right side of minimum X coordinate
                            if (isStartXGreaterThanMax || isEndXGreaterThanMax)
                            {
                                double maxX = Math.Max(XToBeMoved, XEndToBeMoved);
                                if (GeometryWidth >= GeotextileWidth)
                                {
                                    repairedGeotextile.StartX -= maxX;
                                    repairedGeotextile.EndX -= maxX;
                                }
                                else
                                {
                                    SetMinMaxToGeotextile(true, repairedGeotextile);
                                }
                            }

                            //Geotextile is Left side of maximum X coordinate
                            if (isStartXLessThanMin || isEndXLessThanMin)
                            {
                                double maxX = Math.Max(XToBeMoved, XEndToBeMoved);
                                if (GeometryWidth >= GeotextileWidth)
                                {
                                    repairedGeotextile.StartX += maxX;
                                    repairedGeotextile.EndX += maxX;
                                }
                                else
                                {
                                    SetMinMaxToGeotextile(true, repairedGeotextile);
                                }
                            }

                            #endregion

                            #region Z Repair

                            //Geotextile is outside the geometry at top and bottom.
                            if ((isStartZLessThanMin && isEndZGreaterThanMax) || (isStartZGreaterThanMax && isEndZLessThanMin))
                            {
                                SetMinMaxToGeotextile(false, repairedGeotextile);
                                isStartZGreaterThanMax = false;
                                isStartZLessThanMin = false;
                                isEndZGreaterThanMax = false;
                                isEndZLessThanMin = false;
                            }

                            //Geotextile is Top of minimum Z coordinate
                            if (isStartZGreaterThanMax || isEndZGreaterThanMax)
                            {
                                double maxZ = Math.Max(ZToBeMoved, ZEndToBeMoved);
                                if (GeometryHeight >= GeotextileHeight)
                                {
                                    repairedGeotextile.StartZ -= maxZ;
                                    repairedGeotextile.EndZ -= maxZ;
                                }
                                else
                                {
                                    SetMinMaxToGeotextile(false, repairedGeotextile);
                                }
                            }

                            //Geotextile is bottom of maximum Z coordinate
                            if (isStartZLessThanMin || isEndZLessThanMin)
                            {
                                double maxZ = Math.Max(ZToBeMoved, ZEndToBeMoved);
                                if (GeometryHeight >= GeotextileHeight)
                                {
                                    repairedGeotextile.StartZ += maxZ;
                                    repairedGeotextile.EndZ += maxZ;
                                }
                                else
                                {
                                    SetMinMaxToGeotextile(false, repairedGeotextile);
                                }
                            }

                            #endregion
                        }
                        else if (property == "StartX")
                        {
                            ((Geotextile)subject).StartX = (((Geotextile)subject).StartX > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "StartZ")
                        {
                            ((Geotextile)subject).StartZ = (((Geotextile)subject).StartZ > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "EndX")
                        {
                            ((Geotextile)subject).EndX = (((Geotextile)subject).EndX > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "EndZ")
                        {
                            ((Geotextile)subject).EndZ = (((Geotextile)subject).EndZ > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(ForbiddenLines))
                    {
                        if (property == "All")
                        {
                            #region Init

                            double XToBeMoved = 0.00;
                            double ZToBeMoved = 0.00;
                            double XEndToBeMoved = 0.00;
                            double ZEndToBeMoved = 0.00;
                            double ForbiddenLineWidth = 0.00;
                            double ForbiddenLineHeight = 0.00;
                            double GeometryWidth = 0.00;
                            double GeometryHeight = 0.00;

                            bool isStartXLessThanMin = false;
                            bool isStartXGreaterThanMax = false;
                            bool isStartZLessThanMin = false;
                            bool isStartZGreaterThanMax = false;
                            bool isEndXLessThanMin = false;
                            bool isEndXGreaterThanMax = false;
                            bool isEndZLessThanMin = false;
                            bool isEndZGreaterThanMax = false;

                            var repairedForbiddenLine = (ForbiddenLines) subject;
                            ForbiddenLineWidth = Math.Abs(repairedForbiddenLine.EndX - repairedForbiddenLine.StartX);
                            ForbiddenLineHeight = Math.Abs(repairedForbiddenLine.EndZ - repairedForbiddenLine.StartZ);
                            GeometryWidth = Math.Abs(model.GeometryData.MaxGeometryPointsX - model.GeometryData.MinGeometryPointsX);
                            GeometryHeight = Math.Abs(model.GeometryData.MaxGeometryPointsZ - model.GeometryData.MinGeometryPointsZ);

                            #endregion

                            #region Find difference From End Point to Geometry

                            if (repairedForbiddenLine.EndX > model.GeometryData.MaxGeometryPointsX)
                            {
                                isEndXGreaterThanMax = true;
                                XEndToBeMoved = repairedForbiddenLine.EndX - model.GeometryData.MaxGeometryPointsX;
                            }
                            else if (repairedForbiddenLine.EndX < model.GeometryData.MinGeometryPointsX)
                            {
                                isEndXLessThanMin = true;
                                XEndToBeMoved = model.GeometryData.MinGeometryPointsX - repairedForbiddenLine.EndX;
                            }
                            if (repairedForbiddenLine.EndZ > model.GeometryData.MaxGeometryPointsZ)
                            {
                                isEndZGreaterThanMax = true;
                                ZEndToBeMoved = repairedForbiddenLine.EndZ - model.GeometryData.MaxGeometryPointsZ;
                            }
                            else if (repairedForbiddenLine.EndZ < model.GeometryData.MinGeometryPointsZ)
                            {
                                isEndZLessThanMin = true;
                                ZEndToBeMoved = model.GeometryData.MinGeometryPointsZ - repairedForbiddenLine.EndZ;
                            }

                            #endregion

                            #region Find difference From Start Point to Geometry

                            if (repairedForbiddenLine.StartX > model.GeometryData.MaxGeometryPointsX)
                            {
                                isStartXGreaterThanMax = true;
                                XToBeMoved = repairedForbiddenLine.StartX - model.GeometryData.MaxGeometryPointsX;
                            }
                            else if (repairedForbiddenLine.StartX < model.GeometryData.MinGeometryPointsX)
                            {
                                isStartXLessThanMin = true;
                                XToBeMoved = model.GeometryData.MinGeometryPointsX - repairedForbiddenLine.StartX;
                            }
                            if (repairedForbiddenLine.StartZ > model.GeometryData.MaxGeometryPointsZ)
                            {
                                isStartZGreaterThanMax = true;
                                ZToBeMoved = repairedForbiddenLine.StartZ - model.GeometryData.MaxGeometryPointsZ;
                            }
                            else if (repairedForbiddenLine.StartZ < model.GeometryData.MinGeometryPointsZ)
                            {
                                isStartZLessThanMin = true;
                                ZToBeMoved = model.GeometryData.MinGeometryPointsZ - repairedForbiddenLine.StartZ;
                            }

                            #endregion

                            #region X Repair

                            //Forbidden Line is outside the geometry in left and right sides.
                            if ((isStartXLessThanMin && isEndXGreaterThanMax) || (isStartXGreaterThanMax && isEndXLessThanMin))
                            {
                                SetMinMaxToForbiddenLine(true, repairedForbiddenLine);
                            }

                            //Forbidden Line is Right side of minimum X coordinate
                            if (isStartXGreaterThanMax || isEndXGreaterThanMax)
                            {
                                double maxX = Math.Max(XToBeMoved, XEndToBeMoved);
                                if (GeometryWidth >= ForbiddenLineWidth)
                                {
                                    repairedForbiddenLine.StartX -= maxX;
                                    repairedForbiddenLine.EndX -= maxX;
                                }
                                else
                                {
                                    SetMinMaxToForbiddenLine(true, repairedForbiddenLine);
                                }
                            }

                            //Forbidden Line is Left side of maximum X coordinate
                            if (isStartXLessThanMin || isEndXLessThanMin)
                            {
                                double maxX = Math.Max(XToBeMoved, XEndToBeMoved);
                                if (GeometryWidth >= ForbiddenLineWidth)
                                {
                                    repairedForbiddenLine.StartX += maxX;
                                    repairedForbiddenLine.EndX += maxX;
                                }
                                else
                                {
                                    SetMinMaxToForbiddenLine(true, repairedForbiddenLine);
                                }
                            }

                            #endregion

                            #region Z Repair

                            //Forbidden Line is outside the geometry at top and bottom.
                            if ((isStartZLessThanMin && isEndZGreaterThanMax) || (isStartZGreaterThanMax && isEndZLessThanMin))
                            {
                                SetMinMaxToForbiddenLine(false, repairedForbiddenLine);
                                isStartZGreaterThanMax = false;
                                isStartZLessThanMin = false;
                                isEndZGreaterThanMax = false;
                                isEndZLessThanMin = false;
                            }

                            //Forbidden Line is Top of minimum Z coordinate
                            if (isStartZGreaterThanMax || isEndZGreaterThanMax)
                            {
                                double maxZ = Math.Max(ZToBeMoved, ZEndToBeMoved);
                                if (GeometryHeight >= ForbiddenLineHeight)
                                {
                                    repairedForbiddenLine.StartZ -= maxZ;
                                    repairedForbiddenLine.EndZ -= maxZ;
                                }
                                else
                                {
                                    SetMinMaxToForbiddenLine(false, repairedForbiddenLine);
                                }
                            }

                            //Forbidden Line is bottom of maximum Z coordinate
                            if (isStartZLessThanMin || isEndZLessThanMin)
                            {
                                double maxZ = Math.Max(ZToBeMoved, ZEndToBeMoved);
                                if (GeometryHeight >= ForbiddenLineHeight)
                                {
                                    repairedForbiddenLine.StartZ += maxZ;
                                    repairedForbiddenLine.EndZ += maxZ;
                                }
                                else
                                {
                                    SetMinMaxToForbiddenLine(false, repairedForbiddenLine);
                                }
                            }

                            #endregion
                        }
                        else if (property == "StartX")
                        {
                            ((ForbiddenLines)subject).StartX = (((ForbiddenLines)subject).StartX > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "StartZ")
                        {
                            ((ForbiddenLines)subject).StartZ = (((ForbiddenLines)subject).StartZ > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "EndX")
                        {
                            ((ForbiddenLines)subject).EndX = (((ForbiddenLines)subject).EndX > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "EndZ")
                        {
                            ((ForbiddenLines)subject).EndZ = (((ForbiddenLines)subject).EndZ > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(SlipCircle))
                    {
                        if (property == "TangentLineZTop")
                        {
                            ((SlipCircle)subject).SlipCircleTangentLine.TangentLineZTop = (((SlipCircle)subject).SlipCircleTangentLine.TangentLineZTop > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "TangentLineZBottom")
                        {
                            ((SlipCircle)subject).SlipCircleTangentLine.TangentLineZBottom = (((SlipCircle)subject).SlipCircleTangentLine.TangentLineZBottom > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "XFixed")
                        {
                            ((SlipCircle)subject).SlipCircleFixedPoint.XFixed = (((SlipCircle)subject).SlipCircleFixedPoint.XFixed > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "ZFixed")
                        {
                            ((SlipCircle)subject).SlipCircleFixedPoint.ZFixed = (((SlipCircle)subject).SlipCircleFixedPoint.ZFixed > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(HorizontalBalance))
                    {
                        if (property == "XLeft")
                        {
                            ((HorizontalBalance)subject).XLeft = (((HorizontalBalance)subject).XLeft > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "XRight")
                        {
                            ((HorizontalBalance)subject).XRight = (((HorizontalBalance)subject).XRight > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "ZBottom")
                        {
                            ((HorizontalBalance)subject).ZBottom = (((HorizontalBalance)subject).ZBottom > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "ZTop")
                        {
                            ((HorizontalBalance)subject).ZTop = (((HorizontalBalance)subject).ZTop > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(SlipPlaneUpliftVan))
                    {
                        if (property == "GridXLeft")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridXLeft = (((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridXLeft > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridXRight")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridXRight = (((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridXRight > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridZBottom")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridZBottom = (((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridZBottom > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridZTop")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridZTop = (((SlipPlaneUpliftVan)subject).SlipPlaneLeftGrid.GridZTop > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "TangentLineZTop")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneTangentLine.TangentLineZTop = (((SlipPlaneUpliftVan)subject).SlipPlaneTangentLine.TangentLineZTop > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "TangentLineZBottom")
                        {
                            ((SlipPlaneUpliftVan)subject).SlipPlaneTangentLine.TangentLineZBottom = (((SlipPlaneUpliftVan)subject).SlipPlaneTangentLine.TangentLineZBottom > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(SlipCircleGrid))
                    {
                        if (property == "GridXLeft")
                        {
                            ((SlipCircleGrid)subject).GridXLeft = (((SlipCircleGrid)subject).GridXLeft > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridXRight")
                        {
                            ((SlipCircleGrid)subject).GridXRight = (((SlipCircleGrid)subject).GridXRight > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridZBottom")
                        {
                            ((SlipCircleGrid)subject).GridZBottom = (((SlipCircleGrid)subject).GridZBottom > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "GridZTop")
                        {
                            ((SlipCircleGrid)subject).GridZTop = (((SlipCircleGrid)subject).GridZTop > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(TreeOnSlope))
                    {
                        if (property == "X")
                        {
                            ((TreeOnSlope)subject).X = (((TreeOnSlope)subject).X > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                        }
                        else if (property == "Z")
                        {
                            ((TreeOnSlope)subject).Z = (((TreeOnSlope)subject).Z > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                    }
                    else if (subject.GetType() == typeof(GeometryPoint))
                    {
                        var geomPoint = (GeometryPoint) subject;

                        #region SlipPlane

                        int slipplaneIndex = model.SlipPlanes.Count - 1;
                        if (slipplaneIndex >= 0)
                        {
                            if (model.SlipPlanes[0].Points.Contains(geomPoint) || (slipplaneIndex > 0 && model.SlipPlanes[1].Points.Contains(geomPoint)))
                            {
                                if (property == "X")
                                {
                                    SetValueOfPoint(true, geomPoint);
                                }
                                else if (property == "Z")
                                {
                                    SetValueOfPoint(false, geomPoint);
                                }
                            }
                        }

                        #endregion

                        #region Reference level line

                        if (model.ReferenceLevelLine != null)
                        {
                            if (model.ReferenceLevelLine.Points.Contains(geomPoint))
                            {
                                if (property == "X")
                                {
                                    SetValueOfPoint(true, geomPoint);
                                }
                                else if (property == "Z")
                                {
                                    SetValueOfPoint(false, geomPoint);
                                }
                            }
                        }

                        #endregion

                        #region Forbidden lines

                        if (model.ForbiddenLinesList.Count > 0)
                        {
                            foreach (var forbiddenLine in model.ForbiddenLinesList)
                            {
                                if (forbiddenLine.StartPoint == geomPoint || forbiddenLine.EndPoint == geomPoint)
                                {
                                    if (property == "All")
                                    {
                                        SetValueOfPoint(true, geomPoint);
                                        SetValueOfPoint(false, geomPoint);
                                    }
                                    forbiddenLine.StartPoint = forbiddenLine.StartPoint;
                                    forbiddenLine.EndPoint = forbiddenLine.EndPoint;
                                    break;
                                }
                            }
                        }

                        #endregion

                        #region Geotextile

                        if (model.Geotextiles.Count > 0)
                        {
                            foreach (var geotextile in model.Geotextiles)
                            {
                                if (geotextile.StartPoint == geomPoint || geotextile.EndPoint == geomPoint)
                                {
                                    if (property == "All")
                                    {
                                        SetValueOfPoint(true, geomPoint);
                                        SetValueOfPoint(false, geomPoint);
                                    }
                                    geotextile.StartPoint = geotextile.StartPoint;
                                    geotextile.EndPoint = geotextile.EndPoint;
                                    break;
                                }
                            }
                        }

                        #endregion
                    }
                    else if (subject.GetType() == typeof(ZoneAreas))
                    {
                        if (property == "DikeTableHeight")
                        {
                            model.ZoneAreas.DikeTableHeight = (model.ZoneAreas.DikeTableHeight > model.GeometryData.MaxGeometryPointsZ + 20) ? model.GeometryData.MaxGeometryPointsZ + 20 : model.GeometryData.MinGeometryPointsZ;
                        }
                        else if (property == "DesignLevelInfluenceY")
                        {
                            model.ZoneAreas.DesignLevelInfluenceY = (model.ZoneAreas.DesignLevelInfluenceY > model.GeometryData.MaxGeometryPointsZ) ? model.GeometryData.MaxGeometryPointsZ : model.GeometryData.MinGeometryPointsZ;
                        }
                        else
                        {
                            double value = Convert.ToDouble(subject.GetType().GetProperty(property).GetValue(subject, null));
                            double validValue = (value > model.GeometryData.MaxGeometryPointsX) ? model.GeometryData.MaxGeometryPointsX : model.GeometryData.MinGeometryPointsX;
                            subject.GetType().GetProperty(property).SetValue(subject, validValue, null);
                        }
                    }
                }
                else if (id == NOT_INCREASING)
                {
                    var geomPoint = (GeometryPoint) subject;

                    #region SlipPlane

                    int slipplaneIndex = model.SlipPlanes.Count - 1;
                    if (slipplaneIndex < 0)
                    {
                        return;
                    }
                    //isSlipPlane = true;
                    if (model.SlipPlanes[0].Points.Contains(geomPoint) || (slipplaneIndex > 0 && model.SlipPlanes[1].Points.Contains(geomPoint)))
                    {
                        int geomPointIndex = -1;
                        if (slipplaneIndex > 0 && model.SlipPlanes[1].Points.Contains(geomPoint))
                        {
                            geomPointIndex = model.SlipPlanes[1].Points.IndexOf(geomPoint);
                            if (property == "X")
                            {
                                geomPoint.X = model.SlipPlanes[1].Points[geomPointIndex - 1].X;
                            }
                            else if (property == "Z")
                            {
                                geomPoint.Z = model.SlipPlanes[1].Points[geomPointIndex - 1].Z;
                            }
                        }
                        else
                        {
                            geomPointIndex = model.SlipPlanes[0].Points.IndexOf(geomPoint);
                            if (property == "X")
                            {
                                geomPoint.X = model.SlipPlanes[0].Points[geomPointIndex - 1].X;
                            }
                            else if (property == "Z")
                            {
                                geomPoint.Z = model.SlipPlanes[0].Points[geomPointIndex - 1].Z;
                            }
                        }
                    }

                    #endregion
                }
                else if (id == NO_SOIL)
                {
                    if (subject.GetType() == typeof(SoilLayer2D))
                    {
                        if (model.SoilModel.DefaultStabilitySoilMaterial != null)
                        {
                            ((SoilLayer2D) subject).Soil = model.SoilModel.DefaultStabilitySoilMaterial;
                            DataEventPublisher.Changed(typeof(SoilLayer2D), null);
                        }
                    }
                }
                else if (id == SAME_START_AND_END_POINT)
                {
                    if (subject is Geotextile || subject is ForbiddenLines)
                    {
                        model.Remove((IGeometryObject) subject, true);
                    }
                    else if (subject is GeometryPoint)
                    {
                        var deletedObject = new List<IGeometryObject>();
                        deletedObject.Add((IGeometryObject) subject);
                        model.HandleDelete(deletedObject);
                    }
                }
                else if (id == NOT_ON_SURFACE)
                {
                    if (subject is GeometryPoint)
                    {
                        var geometryPoint = (GeometryPoint) subject;
                        geometryPoint.Z = model.GeometryData.GetSurfaceHeight(geometryPoint.X);
                        DataEventPublisher.Changed(geometryPoint, null);
                    }
                    else if (subject is Nail)
                    {
                        var geometryPoint = ((Nail) subject).NailHeadPoint;
                        geometryPoint.Z = model.GeometryData.GetSurfaceHeight(geometryPoint.X);
                        DataEventPublisher.Changed(subject, null);
                        DataEventPublisher.DoRefreshView(null);
                    }
                }
                else if (id == CANNOT_BE_ZERO)
                {
                    var nail = subject as Nail;
                    if (nail != null)
                    {
                        if (property == "Length")
                        {
                            nail.Length = 1;
                        }
                    }
                }
            }
            catch {}
        }

        public string GetRepairDescription(object subject, string property, string id)
        {
            if (id.Equals("Outside geometry limits") || id.Equals(LESS_THAN_MIN) || id.Equals(GREATER_THAN_MAX))
            {
                return "Move within geometry bounds";
            }
            else if (id.Equals(NOT_INCREASING))
            {
                return "Make X coordinates increasing";
            }
            else if (id.Equals(NO_SOIL))
            {
                return "Assign default soil";
            }
            else if (id.Equals(SAME_START_AND_END_POINT))
            {
                if (subject is Geotextile)
                {
                    return "Delete geotextile";
                }
                else if (subject is ForbiddenLines)
                {
                    return "Delete forbidden line";
                }
                else if (subject is GeometryPoint)
                {
                    return "Delete point";
                }
            }

            return "Repair";
        }

        #endregion

    }
}