// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Piping Kernels.
//
// The Dam Macrostability Kernel 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.DamPiping.BlighCalculator;
using System;
using NUnit.Framework;

namespace Deltares.DamPiping.BlighCalculatorTests
{
    [TestFixture]
    public class PipingCalculatorBlighTests
    {

        [Test]
        public void TestIf64Bit()
        {
            var ls = IntPtr.Size;
            Assert.AreEqual(8, ls);
            Assert.That(Environment.Is64BitProcess, Is.True);
        }

        [Test]
        public void TestCalculationDefault()
        {
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 1
            };
            calculator.Calculate();
            Assert.AreEqual(0, calculator.FoSp);
            Assert.AreEqual(0, calculator.Hc);
        }

        [Test]
        public void TestCalculation()
        {
            // expected results are based on test in 'https://repos.deltares.nl/repos/dam/dam classic' revision 190
            // Hc = SeepageLength / CreepFactor = 40.5 / 18 = 2.25
            // CreepFactor is calculated with D70
            // reducedFall = HRiver - HExit - (Rc * DTotal) = 2.0 - 0.0 - (0.3 * 5.0) = 0.5
            // FoSp = Hc / reducedFall = 2.25 / 0.5
            const double diff = 0.0001;
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 2.0,
                HExit = 0.0,
                Rc = 0.3,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0 
            };
            calculator.Calculate();
            Assert.AreEqual(4.5, calculator.FoSp, diff);
            Assert.AreEqual(2.25, calculator.Hc, diff);
        }

        [Test]
        public void TestCreepFactor()
        {
            // expected results are based on code in 'https://repos.deltares.nl/repos/dam/dam classic' revision 190
            var calculator = new PipingCalculatorBligh();
            calculator.D70 = 180.0; // d50 < 150 
            var factor = calculator.CreepFactor();
            Assert.AreEqual(18.0, factor);

            calculator.D70 = 200; // 150 < d50 < 300 
            factor = calculator.CreepFactor();
            Assert.AreEqual(15.0, factor);

            calculator.D70 = 400; // 300 > d50 
            factor = calculator.CreepFactor();
            Assert.AreEqual(12.0, factor);

            calculator.D70 = null; // d70 not specified
            factor = calculator.CreepFactor();
            Assert.AreEqual(18.0, factor);
        }

        [Test]
        public void TestGetReducedFall()
        {
            // reduced fall = HRiver - HExit - (Rc * DTotal)
            const double cTolerance = 0.01;
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 1.0,
                HExit = 0.0,
                Rc = 0.3,
                DTotal = 2.0,
            };
            var reducedFall = calculator.GetReducedFall();
            Assert.AreEqual(0.40, reducedFall, cTolerance);

            calculator.HRiver = 0.0;
            calculator.HExit = -2.0;
            calculator.Rc = 0.2;
            calculator.DTotal = 6.0;
            reducedFall = calculator.GetReducedFall();
            Assert.AreEqual(0.80, reducedFall, cTolerance);
        }

        [Test]
        public void TestDetermineFactorOfSafety()
        {
            // foSp = hc / reducedFall
            const double cTolerance = 0.01;

            var hCritical = 3.65;
            var reducedFall = 1.00;
            var safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
            Assert.AreEqual(3.65, safetyFactor, cTolerance);

            hCritical = 3.65;
            reducedFall = 2.00;
            safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
            Assert.AreEqual(1.825, safetyFactor, cTolerance);

            // reducedFall <= 0 result is cDefaultMaxReturnValue = 90.0;
            hCritical = 3.65;
            reducedFall = 0.00;
            safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
            Assert.AreEqual(90.0, safetyFactor, cTolerance);

            // hCritical = 0 result is cDefaultMinReturnValue = 0.0;
            hCritical = 0.00;
            reducedFall = 1.00;
            safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
            Assert.AreEqual(0.0, safetyFactor, cTolerance);
        }

        [Test]
        public void TestValidateNaNParameter()
        {
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 2.0,
                HExit = 0.0,
                Rc = 0.3,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0
            };
            var originalErrors = calculator.Validate();

            calculator.HRiver = double.NaN;
            calculator.HExit = double.NaN;
            calculator.Rc = double.NaN;
            calculator.DTotal = double.NaN;
            calculator.SeepageLength = double.NaN;
            calculator.D70 = double.NaN;
            var nanErrors = calculator.Validate();
            Assert.AreEqual(originalErrors.Count + 6, nanErrors.Count);

            //  D70 is allowed to be null
            calculator.D70 = null;
            nanErrors = calculator.Validate();
            Assert.AreEqual(originalErrors.Count + 5, nanErrors.Count);
        }

        [Test]
        [SetUICulture("en-US")]
        public void TestValidateRcLessThan0En()
        {
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 2.0,
                HExit = 0.0,
                Rc = -1e-6,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0
            };
            var errors = calculator.Validate();
            Assert.AreEqual(1, errors.Count);
            var expectedMessageEN = "Rc may not be less than 0.";
            CollectionAssert.AreEqual(new[] {expectedMessageEN}, errors);
        }

        [Test]
        [SetUICulture("nl-NL")]
        public void TestValidateRcLessThan0Nl()
        {
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 2.0,
                HExit = 0.0,
                Rc = -1e-6,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0
            };
            var errors = calculator.Validate();
            Assert.AreEqual(1, errors.Count);
            var expectedMessageNL = "De waarde voor de dempingsfactor mag niet lager dan 0 zijn.";
            CollectionAssert.AreEqual(new[] { expectedMessageNL }, errors);
        }

        [Test]
        [SetUICulture("nl-NL")]
        public void TestValidateReducedFall()
        {
            var calculator = new PipingCalculatorBligh
            {
                HRiver = 2.0,
                HExit = 2.0,
                Rc = 0,
                DTotal = 5.0,
                SeepageLength = 40.5,
                D70 = 180.0
            };
            var errors = calculator.Validate();
            Assert.AreEqual(1, errors.Count);
            var expectedMessageEN = "De term HRiver - HExit - (Rc*DTotal) mag niet nul zijn.";
            CollectionAssert.AreEqual(new[] { expectedMessageEN }, errors);
        }

    }
}