// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the application DAM - UI.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU 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.Dam.Data;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class DesignPointCalculationTest
    {
        [Test]
        public void TestCalculationMaxLevelAboveTopLevel()
        {
            Assert.AreEqual(4.18882, PerformBasicCorrectCalculation(true, 4.90), CTolerance);
        }

        [Test]
        public void TestCalculationMaxLevelBelowLowestLevel()
        {
            Assert.AreEqual(6.4903, PerformBasicCorrectCalculation(true, 0.90), CTolerance);
        }

        [Test]
        [Ignore("reason for this failure is to be checked by Best!")]
        public void TestCalculationMaxLevelBelowTopLevelDoesNotConverge()
        {
            PerformBasicCorrectCalculation(true, 2.95);
            // reason for this to be checked by Best!
            Assert.IsFalse(FDDesignPointWater.ErrorMessage == "");
        }

        [Test]
        public void TestCalculationMaxLevelMiddleTopLevel()
        {
            Assert.AreEqual(4.4422, PerformBasicCorrectCalculation(true, 2.70), CTolerance);
        }

        [Test]
        public void TestCalculationWithMaxLevelEqualToTopLevel()
        {
            Assert.AreEqual(4.18882, PerformBasicCorrectCalculation(true, 3.90), CTolerance);
        }

        [Test]
        public void TestCalculationWithSortedDataEqualsCalculationWithUnsortedData()
        {
            Assert.AreEqual(PerformBasicCorrectCalculation(false, 0), PerformCalculationWithUnsortedData(false, 0), CTolerance);
        }

        [Test]
        public void TestCalculationWithZeroData()
        {
            Assert.AreEqual(0, PerformCalculationWithZeroData(false, 0), CTolerance);
        }

        [Test]
        public void TestCalculationWithoutMaxLevel()
        {
            Assert.AreEqual(4.18882, PerformBasicCorrectCalculation(false, 0), CTolerance);
        }

        [Test]
        public void TestCalculationWithoutMaxLevelEqualsCalculationWithMaxLevelAboveToTopLevel()
        {
            Assert.AreEqual(PerformBasicCorrectCalculation(false, 0), PerformBasicCorrectCalculation(true, 4.90), CTolerance);
        }

        [Test]
        public void TestCalculationWithoutMaxLevelEqualsCalculationWithMaxLevelEqualToTopLevel()
        {
            Assert.AreEqual(PerformBasicCorrectCalculation(false, 0), PerformBasicCorrectCalculation(true, 3.90), CTolerance);
        }

        private DesignPointCalculation FDDesignPointWater;
        private double CTolerance = 0.0001;

        private void SetLevelsForCalculation(double ALevel1, double ALevel2, double ALevel3)
        {
            double[] LWaterlevels;

            LWaterlevels = new double[3];
            LWaterlevels[0] = ALevel1;
            LWaterlevels[1] = ALevel2;
            LWaterlevels[2] = ALevel3;
            FDDesignPointWater.Waterlevels = LWaterlevels;
        }

        private void SetBetasForCalculation(double ABeta1, double ABeta2, double ABeta3)
        {
            double[] LBetas;

            LBetas = new double[3];
            LBetas[0] = ABeta1;
            LBetas[1] = ABeta2;
            LBetas[2] = ABeta3;
            FDDesignPointWater.Betas = LBetas;
        }

        private double PerformBasicCorrectCalculation(bool AMaxLevelUsed, double AMaxLevel)
        {
            double cNoResult = -999.99;
            double LBeta;

            LBeta = cNoResult;
            FDDesignPointWater = new DesignPointCalculation();
            SetLevelsForCalculation(1.0, 2.9, 3.9);
            SetBetasForCalculation(6.37653, 4.214663, 3.725901);

            FDDesignPointWater.MHW = 3.90;
            FDDesignPointWater.Decimate = 0.31;
            FDDesignPointWater.Exceed = DesignPointCalculation.ExceedingSet.twoThousend;
            FDDesignPointWater.IsMaxLevelUsed = AMaxLevelUsed;
            FDDesignPointWater.MaxLevel = AMaxLevel;

            if (FDDesignPointWater.CalculateTheWaterDesignpoint())
            {
                LBeta = FDDesignPointWater.Beta;
            }
            return LBeta;
        }

        private double PerformCalculationWithUnsortedData(bool AMaxLevelUsed, double AMaxLevel)
        {
            double cNoResult = -999.99;
            double LBeta;

            LBeta = cNoResult;
            FDDesignPointWater = new DesignPointCalculation();
            SetLevelsForCalculation(2.9, 1.0, 3.9);
            SetBetasForCalculation(4.214663, 6.37653, 3.725901);

            FDDesignPointWater.MHW = 3.90;
            FDDesignPointWater.Decimate = 0.31;
            FDDesignPointWater.Exceed = DesignPointCalculation.ExceedingSet.twoThousend;
            FDDesignPointWater.IsMaxLevelUsed = AMaxLevelUsed;
            FDDesignPointWater.MaxLevel = AMaxLevel;

            if (FDDesignPointWater.CalculateTheWaterDesignpoint())
            {
                LBeta = FDDesignPointWater.Beta;
            }
            return LBeta;
        }

        private double PerformCalculationWithZeroData(bool AMaxLevelUsed, double AMaxLevel)
        {
            double cNoResult = -999.99;
            double LBeta;

            LBeta = cNoResult;
            FDDesignPointWater = new DesignPointCalculation();
            SetLevelsForCalculation(0, 0, 0);
            SetBetasForCalculation(0, 0, 0);

            FDDesignPointWater.MHW = 3.90;
            FDDesignPointWater.Decimate = 0.31;
            FDDesignPointWater.Exceed = DesignPointCalculation.ExceedingSet.twoThousend;
            FDDesignPointWater.IsMaxLevelUsed = AMaxLevelUsed;
            FDDesignPointWater.MaxLevel = AMaxLevel;

            if (FDDesignPointWater.CalculateTheWaterDesignpoint())
            {
                LBeta = FDDesignPointWater.Beta;
            }
            return LBeta;
        }
    }
}