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

using Deltares.DamEngine.Calculators.Uplift;
using Deltares.DamEngine.Data.Geotechnics;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.Uplift
{
    [TestFixture]
    internal class SoilVolumeMassCalculatorEffectiveStressTest
    {
        [Test]
        public void CalculateWithExceedingMinimumThicknessCoverLayerAndLowSurfaceLevelFullySubmerged()
        {
            const double expectedResult = 109.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 9.5;
            soilVolumeMassCalculator.PhreaticLevel = 0;
            soilVolumeMassCalculator.SurfaceLevel = -1.5;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithExceedingMinimumThicknessCoverLayerAndLowSurfaceLevelPartlySubmerged()
        {
            const double expectedResult = 121.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 9.5;
            soilVolumeMassCalculator.PhreaticLevel = -2;
            soilVolumeMassCalculator.SurfaceLevel = -1.5;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithExceedingMinimumThicknessCoverLayerFullySubmerged()
        {
            const double expectedResult = 134.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 12;
            soilVolumeMassCalculator.PhreaticLevel = 5;
            soilVolumeMassCalculator.SurfaceLevel = 0;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithExceedingMinimumThicknessCoverLayerPartlySubmerged()
        {
            const double expectedResult = 166.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 12;
            soilVolumeMassCalculator.PhreaticLevel = -2;
            soilVolumeMassCalculator.SurfaceLevel = 0;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithoutExceedingMinimumThicknessCoverLayerAndLowSurfaceLevelFullySubmerged()
        {
            const double expectedResult = 99.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 5;
            soilVolumeMassCalculator.PhreaticLevel = 0;
            soilVolumeMassCalculator.SurfaceLevel = -1.5;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithoutExceedingMinimumThicknessCoverLayerAndLowSurfaceLevelPartlySubmerged()
        {
            const double expectedResult = 103.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 5;
            soilVolumeMassCalculator.PhreaticLevel = -2;
            soilVolumeMassCalculator.SurfaceLevel = -1.5;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithoutExceedingMinimumThicknessCoverLayerFullySubmerged()
        {
            const double expectedResult = 114.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.SurfaceLevel = 0;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void CalculateWithoutExceedingMinimumThicknessCoverLayerPartlySubmerged()
        {
            const double expectedResult = 130.000;
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.PhreaticLevel = -2;
            soilVolumeMassCalculator.SurfaceLevel = 0;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -10;
            soilVolumeMassCalculator.VolumicWeightOfWater = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            double result = soilVolumeMassCalculator.CalculateEffectiveStress();
            Assert.AreEqual(expectedResult, result, 0.001);
        }

        [Test]
        public void ThrowsExceptionIfSoilProfileHasNoLayers()
        {
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.SurfaceLevel = 2;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -1;
            soilVolumeMassCalculator.SoilProfile = new SoilProfile1D();
            Assert.That(() => soilVolumeMassCalculator.CalculateEffectiveStress(), Throws.InstanceOf<SoilVolumicMassCalculatorException>());
        }

        [Test]
        public void ThrowsExceptionIfSoilProfileNotAssignedInSoilVolumeMassCalculator()
        {
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.SurfaceLevel = 2;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -1;
            Assert.That(() => soilVolumeMassCalculator.CalculateEffectiveStress(), Throws.InstanceOf<SoilVolumicMassCalculatorException>());
        }

        [Test]
        public void ThrowsExceptionIfSurfaceLevelNotInsideProfile()
        {
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.PhreaticLevel = 0;
            soilVolumeMassCalculator.SurfaceLevel = 2;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = -1;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            Assert.That(() => soilVolumeMassCalculator.CalculateEffectiveStress(), Throws.InstanceOf<SoilVolumicMassCalculatorException>());
        }

        [Test]
        public void ThrowsExceptionIfTopLayerToBeEvaluatedNotInsideProfile()
        {
            var soilVolumeMassCalculator = new SoilVolumicMassCalculator();
            soilVolumeMassCalculator.MinimumThicknessCoverLayer = 10;
            soilVolumeMassCalculator.PhreaticLevel = 0;
            soilVolumeMassCalculator.SurfaceLevel = 0;
            soilVolumeMassCalculator.TopOfLayerToBeEvaluated = 10;
            soilVolumeMassCalculator.SoilProfile = CreateTestProfile();
            Assert.That(() => soilVolumeMassCalculator.CalculateEffectiveStress(), Throws.InstanceOf<SoilVolumicMassCalculatorException>());
        }

        public SoilProfile1D CreateTestProfile()
        {
            var sand = new Soil();
            sand.Name = "zand";
            sand.AbovePhreaticLevel = 15;
            sand.BelowPhreaticLevel = 17;

            var clay = new Soil();
            clay.Name = "klei";
            clay.AbovePhreaticLevel = 18;
            clay.BelowPhreaticLevel = 20;

            var clay2 = new Soil();
            clay2.Name = "klei2";
            clay2.AbovePhreaticLevel = 20;
            clay2.BelowPhreaticLevel = 22;

            var soilProfile = new SoilProfile1D();
            soilProfile.Name = "TestProf";

            var layer1 = new SoilLayer1D();
            layer1.Name = "layer1";
            layer1.TopLevel = 0;
            layer1.Soil = clay;
            soilProfile.Layers.Add(layer1);

            var layer2 = new SoilLayer1D();
            layer2.Name = "layer2";
            layer2.TopLevel = -3;
            layer2.Soil = clay2;
            soilProfile.Layers.Add(layer2);

            var layer3 = new SoilLayer1D();
            layer3.Name = "layer3";
            layer3.TopLevel = -10;
            layer3.Soil = clay2;
            soilProfile.Layers.Add(layer3);

            return soilProfile;
        }
    }
}