using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.Geotechnics.Soils;
using Deltares.Mathematics;
using Deltares.Standard.Language;
using Deltares.Standard.Reflection;
using Deltares.Standard.Validation;

namespace Deltares.Stability
{
    /// <summary>
    /// Validator for <see cref="StabilityModel"/>.<see cref="StabilityModel.PreConsolidationStressList"/>.
    /// </summary>
    public class PreConsolidationStressListValidator
    {
        /// <summary>
        /// <see cref="ValidationResult.ID"/> for <see cref="ValidationResult"/> in case
        /// not enough data is available to perform validation.
        /// </summary>
        public const string CannotValidateMissingDataId = "NO_VALIDATE_MISSING_DATA";

        /// <summary>
        /// <see cref="ValidationResult.ID"/> for <see cref="ValidationResult"/> in case
        /// a data point exists outside of the geometry of the validated soil profile.
        /// </summary>
        public const string DataOutOfBounds = "PRECONSOLIDATION_DATA_OUT_OF_BOUNDS";

        public const string DataOnLayerBoundary = "PRECONSOLIDATION_DATA_ON_LAYER_BOUNDARY";

        private readonly StabilityModel model;

        /// <summary>
        /// Initializes a new instance of the <see cref="PreConsolidationStressListValidator"/> class.
        /// </summary>
        /// <param name="stabilityModel">The stability model to be validated. Cannot be null.</param>
        public PreConsolidationStressListValidator(StabilityModel stabilityModel)
        {
            model = stabilityModel;
        }

        /// <summary>
        /// Validates the data in <see cref="StabilityModel.PreConsolidationStressList"/>.
        /// </summary>
        /// <returns>The collection of validation messages generated by this method.</returns>
        public IValidationResult[] Validate()
        {
            var validationMessages = new List<IValidationResult>();
            if (RequiredDataAvailableForValidation(validationMessages) && IsPreconsolidationStressDataRequired())
            {
                ValidateDataInsideProfileBounds(validationMessages);

                ValidateDataAvailableForSoilProfile(validationMessages);

                ValidateDataNotOnLayerBoundary(validationMessages);
            }
            return validationMessages.ToArray();
        }

        private bool RequiredDataAvailableForValidation(ICollection<IValidationResult> validationMessages)
        {
            var noSoilProfileToValidate = model.SoilProfile == null;
            if (noSoilProfileToValidate)
            {
                return false;
            }

            if (model.SoilProfile.Surfaces.Any(s => s.Soil == null) || model.SurfaceLine2 == null)
            {
                var translate = this.Translate("Validation::NoValidationDueLackingData_LocationName{0}");
                var message = String.Format(translate, model.SoilProfile.Name);

                var validationResult = new ValidationResult(ValidationResultType.Warning, message, model);
                validationResult.AddPropertyAndID(
                    model.GetMemberName(m => m.SoilProfile.PreconsolidationStresses),
                    CannotValidateMissingDataId);
                validationMessages.Add(validationResult);
                return false;
            }

            return true;
        }

        private bool IsPreconsolidationStressDataRequired()
        {
            return model.SoilProfile.Surfaces.Any(s => s.Soil.ShearStrengthModel == ShearStrengthModel.CuCalculated && !s.Soil.UsePop);
        }

        private ValidationResult Create_NoPreconsolidationStress_ValidationResult()
        {
            var translate = this.Translate("Validation::NoPreconsolidationStress_LocationName{0}");
            string message = String.Format(translate, model.SoilProfile.Name);

            var validationResult = new ValidationResult(ValidationResultType.Error, message, model);
            validationResult.Repairer = new MissingPreconsolidationStressRepairer();
            validationResult.AddPropertyAndID(
                model.GetMemberName(m => m.SoilProfile.PreconsolidationStresses),
                MissingPreconsolidationStressRepairer.NoPreconsolidationStressDataId);

            return validationResult;
        }

        private void ValidateDataInsideProfileBounds(ICollection<IValidationResult> validationMessages)
        {
            if (model.SoilProfile.PreconsolidationStresses.Any(PreConsolidationStressOutsideSoilProfileBounds))
            {
                var translate = this.Translate("Validation::PreconsolidationStressOutOfBounds_LocationName{0}");
                string message = String.Format(translate, model.SoilProfile.Name);

                var validationResult = new ValidationResult(ValidationResultType.Error, message, model);
                validationResult.AddPropertyAndID(
                    model.GetMemberName(m => m.SoilProfile.PreconsolidationStresses),
                    DataOutOfBounds);
                validationMessages.Add(validationResult);
            }
        }

        private bool PreConsolidationStressOutsideSoilProfileBounds(PreConsolidationStress preConsolidationStress)
        {
            var heightAtXcoordinate = model.SurfaceLine2.Geometry.GetZAtX(preConsolidationStress.X);
            
            return heightAtXcoordinate < preConsolidationStress.Z;
        }

        private void ValidateDataAvailableForSoilProfile(ICollection<IValidationResult> validationMessages)
        {
            if (!PreConsolidationDataAvailableForSoilProfile())
            {
                validationMessages.Add(Create_NoPreconsolidationStress_ValidationResult());
            }
        }

        private bool PreConsolidationDataAvailableForSoilProfile()
        {
            return model.SoilProfile.PreconsolidationStresses.Any();
        }

        private void ValidateDataNotOnLayerBoundary(ICollection<IValidationResult> validationMessages)
        {
            if (model.SoilProfile.PreconsolidationStresses.Any(PreConsolidationStressOnLayerBoundary))
            {
                var translate = this.Translate("Validation::PreconsolidationStressOnLayerBoundary_LocationName{0}");
                string message = String.Format(translate, model.SoilProfile.Name);

                var validationResult = new ValidationResult(ValidationResultType.Error, message, model);
                validationResult.AddPropertyAndID(
                    model.GetMemberName(m => m.SoilProfile.PreconsolidationStresses),
                    DataOnLayerBoundary);
                validationMessages.Add(validationResult);
            }
        }

        private bool PreConsolidationStressOnLayerBoundary(PreConsolidationStress preConsolidationStress)
        {
            bool result = false;
            Point3D point = new Point3D
            {
                X = preConsolidationStress.X,
                Y = preConsolidationStress.Y,
                Z = preConsolidationStress.Z
            };

            foreach (var curves in model.Geometry.Curves)
            {
                if (curves.ContainsPoint(point, Constants.CGeoAccu))
                {
                    result = true;
                }
            }
            return result;
        }
    }
}