//-----------------------------------------------------------------------
// <copyright file="UpliftCalculator.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>18-05-2009</date>
// <summary>Calculator for Uplift</summary>
//-----------------------------------------------------------------------

using System;
using System.Collections.Generic;
using Deltares.Geometry;
using Deltares.Geotechnics.Soils;
using Deltares.Standard;

namespace Deltares.Geotechnics.WaternetCreator
{
    public class UpliftCalculator
    {
        public UpliftCalculator()
        {
            VolumicWeightOfWater = Physics.UnitWeightOfwater;
            UnitWeightSoilEmbankment = null;
            IsUseOvenDryUnitWeight = false;
        }

        public bool IsUseOvenDryUnitWeight { get; set; }
        public double VolumicWeightOfWater { get; set; }
        public SoilProfile1D SoilProfile { get; set; }
        public double TopOfLayerToBeEvaluated { get; set; }
        public List<GeometryPointString> PLLines { get; set; }
        public double SurfaceLevel { get; set; }
        public double PhreaticLevel { get; set; }
        public double UpLiftTopLevel { get; set; }
        public double? UnitWeightSoilEmbankment { get; set; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="headOfPLLine"></param>
        /// <returns></returns>
        public double CalculateUpliftFactor(double headOfPLLine)
        {
            var massCalculator = CreateSoilVolumeMassCalculator();

            massCalculator.IsUseOvenDryUnitWeight = IsUseOvenDryUnitWeight;
            var mass = massCalculator.Calculate();
            var height = headOfPLLine - TopOfLayerToBeEvaluated;
            var phreaticPressure = VolumicWeightOfWater*height;

            if (phreaticPressure > 0)
            {
                return mass/phreaticPressure;
            }
            else
            {
                return double.MaxValue;
            }
        }

        /// <summary>
        /// Calculate soil extra height to be added to obtain the specified upliftFactor with a given head of PLline
        /// </summary>
        /// <param name="headOfPLLine"></param>
        /// <param name="upliftFactor"></param>
        /// <param name="unitWeightSoil"></param>
        /// <returns>Required extra height</returns>
        public double CalculateExtraHeight(double headOfPLLine, double upliftFactor)
        {
            var massCalculator = CreateSoilVolumeMassCalculator();

            var mass = massCalculator.Calculate();
            var toplevel = Math.Min(SurfaceLevel, TopOfLayerToBeEvaluated);
            var height = headOfPLLine - toplevel;
            var phreaticPressure = VolumicWeightOfWater*height;

            double requiredExtraMass = upliftFactor*phreaticPressure - mass;

            double unitWeightSoil = SoilProfile.Layers[0].Soil.AbovePhreaticLevel;
            if (UnitWeightSoilEmbankment != null)
            {
                unitWeightSoil = UnitWeightSoilEmbankment.Value;
            }

            if (requiredExtraMass > 0)
            {
                return requiredExtraMass/unitWeightSoil;
            }
            else
            {
                return 0.0;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="upliftFactor"></param>
        /// <returns></returns>
        public double CalculateHeadOfPLLine(double upliftFactor)
        {
            var massCalculator = CreateSoilVolumeMassCalculator();
            massCalculator.IsUseOvenDryUnitWeight = IsUseOvenDryUnitWeight;

            var massSoils = massCalculator.Calculate();
            var massWater = massSoils/(upliftFactor*VolumicWeightOfWater);
            return massWater + TopOfLayerToBeEvaluated;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private SoilVolumeMassCalculator CreateSoilVolumeMassCalculator()
        {
            return new SoilVolumeMassCalculator
                {
                    PhreaticLevel = PhreaticLevel,
                    SoilProfile = SoilProfile,
                    TopOfLayerToBeEvaluated = TopOfLayerToBeEvaluated,
                    SurfaceLevel = SurfaceLevel,
                    VolumicWeightOfWater = VolumicWeightOfWater
                };
        }
    }
}