using System.Data;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Calculators.KernelWrappers.MacroStabilityCommon;
using Deltares.DamEngine.Data.Geotechnics;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.MacroStabilityCommon
{
    public class PlLinesToWaternetConverterTests
    {
        [Test]
        public void TestConvertPlLinesToWaternet()
        {
            const double cDif = 0.0001;
            var plLines = CreatePlLinesForTest();

            var soilProfile1D = CreateSoilProfile1DForTest();
            Assert.AreEqual(-2.111, soilProfile1D.InBetweenAquiferLayer.TopLevel, cDif);
            Assert.AreEqual(-6.111, soilProfile1D.BottomAquiferLayer.TopLevel, cDif);

            const double penetrationLength = 2.1;
            const double left = 0;
            const double right = 100;
            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, left, right);

            // Pl 1 is only the phreatic line, a headline or waternetline does not have to be created
            // Pl 2 gets waternetline to level of BottomAquiferLayer.TopLevel + penetrationLength
            // Pl 3 gets waternetline to level of InBetweenAquiferLayer.TopLevel
            // Pl 4 gets waternetline to level of BottomAquiferLayer.TopLevel

            // ex[ected phreatic line from pl 1
            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);
            Assert.AreEqual(0, waternet.PhreaticLine.Points[0].X, cDif);
            Assert.AreEqual(0, waternet.PhreaticLine.Points[0].Z, cDif);
            Assert.AreEqual(50, waternet.PhreaticLine.Points[1].X, cDif);
            Assert.AreEqual(1, waternet.PhreaticLine.Points[1].Z, cDif);
            Assert.AreEqual(100, waternet.PhreaticLine.Points[2].X, cDif);
            Assert.AreEqual(1, waternet.PhreaticLine.Points[2].Z, cDif);
            // expected head lines from pl 2, 3 and 4
            Assert.AreEqual(3, waternet.HeadLineList.Count);
            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
            Assert.AreEqual(3, waternet.HeadLineList[1].Points.Count);
            Assert.AreEqual(2, waternet.HeadLineList[2].Points.Count);
            // check the points of first head line that represents pl 2
            Assert.AreEqual(0, waternet.HeadLineList[0].Points[0].X, cDif);
            Assert.AreEqual(0, waternet.HeadLineList[0].Points[0].Z, cDif);
            Assert.AreEqual(100, waternet.HeadLineList[0].Points[1].X, cDif);
            Assert.AreEqual(-1, waternet.HeadLineList[0].Points[1].Z, cDif);
            // expected waternet lines from pl 2, 3 and 4
            Assert.AreEqual(3, waternet.WaternetLineList.Count);
            // expected waternet line 0 is connected to pl2 with level -6.111 + 2.1 = -4.011
            Assert.AreEqual(waternet.HeadLineList[0], waternet.WaternetLineList[0].HeadLine);
            Assert.AreEqual(0, waternet.WaternetLineList[0].Points[0].X, cDif);
            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[0].Z, cDif);
            Assert.AreEqual(100, waternet.WaternetLineList[0].Points[1].X, cDif);
            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[1].Z, cDif);
            // expected waternet line 1 is connected to pl3 with level -2.111
            Assert.AreEqual(waternet.HeadLineList[1], waternet.WaternetLineList[1].HeadLine);
            Assert.AreEqual(-2.111, waternet.WaternetLineList[1].Points[0].Z, cDif);
            // expected waternet line 2 is connected to pl4 with level -6.111
            Assert.AreEqual(waternet.HeadLineList[2], waternet.WaternetLineList[2].HeadLine);
            Assert.AreEqual(-6.111, waternet.WaternetLineList[2].Points[0].Z, cDif);
        }

        [Test]
        public void TestConvertPlLinesToWaternetWhenNoHeadLinesExpected()
        {
            var plLines = CreatePlLinesForTest();
            var soilProfile1D = CreateSoilProfile1DForTest();
            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, 0, 0, 0);
            // head lines
            Assert.AreEqual(3, waternet.HeadLineList.Count);
            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
            Assert.AreEqual(3, waternet.HeadLineList[1].Points.Count);
            Assert.AreEqual(2, waternet.HeadLineList[2].Points.Count);
            // phreatic line
            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);

            // check that no headline are added when Pl2, Pl3 or Pl4 does not exist or has no points
            plLines.Lines[PlLineType.Pl3] = null;
            plLines.Lines[PlLineType.Pl4].Points.Clear();
            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, 0, 0, 0);
            // head lines
            Assert.AreEqual(1, waternet.HeadLineList.Count);
            Assert.AreEqual(2, waternet.HeadLineList[0].Points.Count);
            // phreatic line
            Assert.AreEqual(3, waternet.PhreaticLine.Points.Count);
        }

        [Test]
        public void TestConvertPlLinesToWaternetWhenNoWaternetLinesExpected()
        {
            const double cDif = 0.0001;
            var plLines = CreatePlLinesForTest();
            var soilProfile1D = CreateSoilProfile1DForTest();
            const double penetrationLength = 2.1;
            var waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
            Assert.AreEqual(3, waternet.HeadLineList.Count);
            Assert.AreEqual(3, waternet.WaternetLineList.Count);

            // check that no waternetlines are added for pl3 when InBetweenAquiferLayer is null
            soilProfile1D = CreateSoilProfile1DWith1AquiferForTest();
            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
            Assert.AreEqual(3, waternet.HeadLineList.Count);
            Assert.AreEqual(2, waternet.WaternetLineList.Count);
            // expected waternet line 0 is connected to pl2 with level -6.111 + 2.1 = -4.011
            Assert.AreEqual(waternet.HeadLineList[0], waternet.WaternetLineList[0].HeadLine);
            Assert.AreEqual(-4.011, waternet.WaternetLineList[0].Points[0].Z, cDif);
            // expected waternet line 1 is connected to pl4 with level -6.111
            Assert.AreEqual(waternet.HeadLineList[2], waternet.WaternetLineList[1].HeadLine);
            Assert.AreEqual(-6.111, waternet.WaternetLineList[1].Points[0].Z, cDif);

            // check that no waternetlines are added for pl2, pl3 and pl4 when BottomAquiferLayer is null
            soilProfile1D = CreateSoilProfile1DWithoutAquifersForTest();
            waternet = PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, soilProfile1D, penetrationLength, 0, 0);
            Assert.AreEqual(3, waternet.HeadLineList.Count);
            Assert.AreEqual(0, waternet.WaternetLineList.Count);
        }

        [Test]
        public void TestConvertLevelToWaternetLine()
        {
            const double cDif = 0.0001;

            const double level = 1.234;
            const double left = -50.111;
            const double right = 50.123;
            var waternetLine = PlLinesToWaternetConverter.ConvertLevelToWaternetLine(level, left, right);

            Assert.AreEqual(2, waternetLine.Points.Count);
            Assert.AreEqual(-50.111, waternetLine.Points[0].X, cDif);
            Assert.AreEqual(1.234, waternetLine.Points[0].Z, cDif);
            Assert.AreEqual(50.123, waternetLine.Points[1].X, cDif);
            Assert.AreEqual(1.234, waternetLine.Points[1].Z, cDif);
        }
        
        [Test]
        public void TestConvertPlLineToHeadLine()
        {
            const double cDif = 0.0001;

            var plLines = new PlLines();
            Assert.AreEqual(4, plLines.PlLineCount);
            var plLine = plLines.Lines[PlLineType.Pl2];
            plLine.Points.Add(new PlLinePoint(-1.234, 4.321));
            plLine.Points.Add(new PlLinePoint(100, 1));
            var headLine = PlLinesToWaternetConverter.ConvertPlLineToHeadLine(plLine);

            Assert.AreEqual(2, headLine.Points.Count);
            Assert.AreEqual(-1.234, headLine.Points[0].X, cDif);
            Assert.AreEqual(4.321, headLine.Points[0].Z, cDif);
            Assert.AreEqual(100, headLine.Points[1].X, cDif);
            Assert.AreEqual(1, headLine.Points[1].Z, cDif);
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen 1D ondergrond profiel gedefinieerd")]
        [SetUICulture("nl-NL")]
        public void TestLanguageNLThrowsExceptionWhenSoilProfile1DIsNull()
        {
            var plLines = new PlLines();
            PlLinesToWaternetConverter.ConvertPlLineToWaternet(plLines, null, 0, 0, 0);
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen object voor pn-lijnen gedefinieerd")]
        [SetUICulture("nl-NL")]
        public void TestLanguageNLThrowsExceptionWhenPlLinesIsNull()
        {
            var soilProfile1D = new SoilProfile1D();
            PlLinesToWaternetConverter.ConvertPlLineToWaternet(null, soilProfile1D, 0, 0, 0);
        }

        private PlLines CreatePlLinesForTest()
        {
            var plLines = new PlLines();
            // pl 1 is phreatic line
            var plLine = plLines.Lines[PlLineType.Pl1];
            plLine.IsPhreatic = true;
            plLine.Points.Add(new PlLinePoint(0, 0));
            plLine.Points.Add(new PlLinePoint(50, 1));
            plLine.Points.Add(new PlLinePoint(100, 1));
            // pl 2 first equal to point of pl 1
            plLine = plLines.Lines[PlLineType.Pl2];
            plLine.Points.Add(new PlLinePoint(0, 0));
            plLine.Points.Add(new PlLinePoint(100, -1));
            // pl 3 
            plLine = plLines.Lines[PlLineType.Pl3];
            plLine.Points.Add(new PlLinePoint(0, 1));
            plLine.Points.Add(new PlLinePoint(50, 0));
            plLine.Points.Add(new PlLinePoint(100, -1));
            // pl 4 
            plLine = plLines.Lines[PlLineType.Pl4];
            plLine.Points.Add(new PlLinePoint(0, -5));
            plLine.Points.Add(new PlLinePoint(100, -5));

            return plLines;
        }

        private SoilProfile1D CreateSoilProfile1DForTest()
        {
            var soilProfile1D = new SoilProfile1D();
            soilProfile1D.BottomLevel = -30.0;

            SoilLayer1D layer = new SoilLayer1D();
            layer.Name = "L1a";
            layer.TopLevel = 1.212;
            layer.IsAquifer = true; // aquifer at top
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L1b";
            layer.TopLevel = 1.212;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L2a";
            layer.TopLevel = -2.111; // top of in-between aquifer 
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L2b";
            layer.TopLevel = -2.151;
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L3";
            layer.TopLevel = -3.373;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L4";
            layer.TopLevel = -4.151;
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L5";
            layer.TopLevel = -5.373;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L6a";
            layer.TopLevel = -6.111; // top of bottom aquifer
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L6b";
            layer.TopLevel = -6.151;
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L7";
            layer.TopLevel = -7.373;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);

            return soilProfile1D;
        }

        private SoilProfile1D CreateSoilProfile1DWith1AquiferForTest()
        {
            var soilProfile1D = new SoilProfile1D();
            soilProfile1D.BottomLevel = -30.0;

            SoilLayer1D layer = new SoilLayer1D();
            layer = new SoilLayer1D();
            layer.Name = "L1b";
            layer.TopLevel = 1.212;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L6a";
            layer.TopLevel = -6.111; // top of bottom aquifer
            layer.IsAquifer = true;
            soilProfile1D.Layers.Add(layer);

            return soilProfile1D;
        }

        private SoilProfile1D CreateSoilProfile1DWithoutAquifersForTest()
        {
            var soilProfile1D = new SoilProfile1D();
            soilProfile1D.BottomLevel = -30.0;

            SoilLayer1D layer = new SoilLayer1D();
            layer = new SoilLayer1D();
            layer.Name = "L1b";
            layer.TopLevel = 1.212;
            layer.IsAquifer = false;
            soilProfile1D.Layers.Add(layer);

            return soilProfile1D;
        }
    }
}