//-----------------------------------------------------------------------
// <copyright file="SoilVolumeMassCalculator.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>16-06-2009</date>
// <summary>Contains class to calculate SoilVolumeMass</summary>
//-----------------------------------------------------------------------

using System;
using System.IO;
using System.Linq;
using Deltares.Geotechnics.Soils;
using Deltares.Standard;
using Deltares.Standard.Extensions;

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

        public bool IsUseOvenDryUnitWeight { get; set; }
        public double VolumicWeightOfWater { get; set; }
        public double PhreaticLevel { get; set; }
        public double SurfaceLevel { get; set; }
        public double TopOfLayerToBeEvaluated { get; set; }
        public SoilProfile1D SoilProfile { get; set; }

        public double Calculate()
        {
            var weight = SoilProfile.Layers
                                    .Where(layer => layer.TopLevel > TopOfLayerToBeEvaluated)
                                    .Sum(layer => GetWeight(layer));

            // Is there water above the soil layer? If so add the volumic weight 
            // of water to the soil mass
            if (PhreaticLevel > SurfaceLevel)
            {
                var height = PhreaticLevel - SurfaceLevel;
                weight += height*VolumicWeightOfWater;
            }

            return weight;
        }

        private double GetWeight(SoilLayer1D layer)
        {
            var soil = layer.Soil as Soil;
            if (soil == null)
            {
                throw new InvalidDataException("soil is not present");
            }

            double topLevel, bottomLevel;
            var height = GetLayerHeight(layer, out topLevel, out bottomLevel);
            var factorWet = 0.0;
            var factorDry = 0.0;

            if (topLevel < PhreaticLevel || topLevel.AlmostEquals(PhreaticLevel))
            {
                factorWet = 1.0;
            }
            else if (bottomLevel > PhreaticLevel || bottomLevel.AlmostEquals(PhreaticLevel))
            {
                factorDry = 1.0;
            }
            else
            {
                var pLevel = (topLevel - PhreaticLevel);
                factorDry = pLevel.AlmostEquals(0.0) ? 0.0 : pLevel/height;
                factorWet = 1.0 - factorDry;
            }

            return GetSoilUnitWeightDry(soil).Value*factorDry*height + soil.BelowPhreaticLevel*factorWet*height;
        }

        private double? GetSoilUnitWeightDry(Soil soil)
        {
            if (IsUseOvenDryUnitWeight)
            {
                return soil.DryUnitWeight;
            }
            else
            {
                return soil.AbovePhreaticLevel;
            }
        }

        private double GetLayerHeight(SoilLayer1D layer, out double topLevel, out double bottomLevel)
        {
            var layerHeight = SoilProfile.GetLayerHeight(layer);
            if (layer.TopLevel > SurfaceLevel)
            {
                topLevel = SurfaceLevel;
                layerHeight = Math.Max(layerHeight - (layer.TopLevel - SurfaceLevel), 0);
            }
            else
            {
                topLevel = layer.TopLevel;
            }

            bottomLevel = topLevel - layerHeight;
            bottomLevel = bottomLevel > TopOfLayerToBeEvaluated ? bottomLevel : TopOfLayerToBeEvaluated;
            return topLevel - bottomLevel;
        }
    }
}