//-----------------------------------------------------------------------
// <copyright file="SoilbaseTest.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T. The</author>
// <email>tom.the@deltares.nl</email>
// <date>8-9-2010</date>
// <summary></summary>
//-----------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using Deltares.Geotechnics;
using Deltares.Probabilistic;
using Deltares.Soilbase.CSVImporter;
using NUnit.Framework;

namespace Deltares.Soilbase.Tests
{
    [TestFixture]
    public class SoilbaseTest
    {
        [SetUp]
        public void TestSetup()
        {
            soilbaseDB = new SoilbaseDB();
        }

        [Test]
        public void CanGetSoilList()
        {
            soilbaseDB = new SoilbaseDB();
            soilbaseDB.Read(TestDatabaseName);
            SoilList soilList = soilbaseDB.GetSoils();
            Assert.AreEqual(37, soilList.Soils.Count);
        }

        [Test]
        public void CanImportAllParamtersSoilsFromCsv()
        {
            var mi = new CsvSoilsImporter();
            const string fileName = @"..\..\..\data\D-Soil Model\Import\Materials\FullExample.csv";
            var soilList = mi.ImportFromFile(fileName);

            Assert.AreEqual(1, soilList.Soils.Count);
            Assert.AreEqual("Leem", soilList.Soils[0].Name);
            Assert.AreEqual(Color.FromArgb(Convert.ToInt32(-5952982)), soilList.Soils[0].Color);
            Assert.AreEqual(SoilType.Loam, soilList.Soils[0].SoilType);
            Assert.AreEqual(1, soilList.Soils[0].DiameterD70);
            Assert.AreEqual(2, soilList.Soils[0].WhitesConstant);
            Assert.AreEqual(3, soilList.Soils[0].BeddingAngle);
            Assert.AreEqual(4, soilList.Soils[0].PermeabKx);
            Assert.AreEqual(5*1e-6, soilList.Soils[0].DiameterD70Stochast.Deviation);
            Assert.AreEqual(DistributionType.Normal, soilList.Soils[0].DiameterD70Stochast.DistributionType);
            Assert.AreEqual(6, soilList.Soils[0].PermeabKxStochast.Deviation);
            Assert.AreEqual(DistributionType.Weibull, soilList.Soils[0].PermeabKxStochast.DistributionType);
            Assert.AreEqual(7, soilList.Soils[0].WhitesConstantStochast.Deviation);
            Assert.AreEqual(DistributionType.Uniform, soilList.Soils[0].WhitesConstantStochast.DistributionType);
            Assert.AreEqual(9, soilList.Soils[0].BeddingAngleStochast.Deviation);
            Assert.AreEqual(DistributionType.LogNormal, soilList.Soils[0].BeddingAngleStochast.DistributionType);
            Assert.AreEqual(10, soilList.Soils[0].AbovePhreaticLevel);
            Assert.AreEqual(11, soilList.Soils[0].BelowPhreaticLevel);
            Assert.AreEqual(12, soilList.Soils[0].DryUnitWeight);
            Assert.AreEqual(13, soilList.Soils[0].ExcessPorePressure);
            Assert.AreEqual(14, soilList.Soils[0].PorePressureFactor);
            Assert.AreEqual(15, soilList.Soils[0].Cohesion);
            Assert.AreEqual(16, soilList.Soils[0].FrictionAngle);
            Assert.AreEqual(17, soilList.Soils[0].RatioCuPc);
            Assert.AreEqual(18, soilList.Soils[0].RatioCuPcPassive);
            Assert.AreEqual(19, soilList.Soils[0].RatioCuPcActive);
            Assert.AreEqual(ShearStrengthModel.CPhi, soilList.Soils[0].ShearStrengthModel);
            Assert.AreEqual(false, soilList.Soils[0].UseDefaultProbabilisticValues);
            Assert.AreEqual(21, soilList.Soils[0].CohesionStochast.Deviation);
            Assert.AreEqual(22, soilList.Soils[0].FrictionAngleStochast.Deviation);
            Assert.AreEqual(23, soilList.Soils[0].PnStochast.Deviation);
            Assert.AreEqual(24, soilList.Soils[0].POPStochast.Deviation);
            Assert.AreEqual(DistributionType.Exponential, soilList.Soils[0].CohesionStochast.DistributionType);
            Assert.AreEqual(DistributionType.Gamma, soilList.Soils[0].FrictionAngleStochast.DistributionType);
            Assert.AreEqual(DistributionType.Beta, soilList.Soils[0].StressTableStochast.DistributionType);
            Assert.AreEqual(DistributionType.Frechet, soilList.Soils[0].PnStochast.DistributionType);
            Assert.AreEqual(DistributionType.TruncatedNormal, soilList.Soils[0].POPStochast.DistributionType);
            Assert.AreEqual(25, soilList.Soils[0].CorrelationCPhi);
            Assert.AreEqual(26, soilList.Soils[0].POP);
            Assert.AreEqual(27, soilList.Soils[0].CohesionStochast.DesignFactor);
            Assert.AreEqual(28, soilList.Soils[0].CohesionStochast.DesignDeviation);
            Assert.AreEqual(29, soilList.Soils[0].FrictionAngleStochast.DesignFactor);
            Assert.AreEqual(30, soilList.Soils[0].FrictionAngleStochast.DesignDeviation);
            Assert.AreEqual(31, soilList.Soils[0].StressTableStochast.DesignFactor);
            Assert.AreEqual(32, soilList.Soils[0].StressTableStochast.DesignDeviation);
            Assert.AreEqual(33, soilList.Soils[0].POPStochast.DesignFactor);
            Assert.AreEqual(34, soilList.Soils[0].POPStochast.DesignDeviation);
            Assert.AreEqual(35, soilList.Soils[0].RRatioStochast.DesignFactor);
            Assert.AreEqual(36, soilList.Soils[0].RRatioStochast.DesignDeviation);
            Assert.AreEqual(37, soilList.Soils[0].SoilGroup);
            Assert.AreEqual(true, soilList.Soils[0].UseSoilType);
            Assert.AreEqual(38, soilList.Soils[0].RRatio);
            Assert.AreEqual(39, soilList.Soils[0].RRatioStochast.Deviation);
            Assert.AreEqual(DistributionType.Deterministic, soilList.Soils[0].RRatioStochast.DistributionType);
            Assert.AreEqual(40, soilList.Soils[0].EMod);
        }

        [Test]
        public void CanImportSoilsFromCsv()
        {
            var mi = new CsvSoilsImporter();
            const string fileName = @"..\..\..\data\D-Soil Model\Import\Materials\Example.csv";
            var soilList = mi.ImportFromFile(fileName);

            Assert.AreEqual(2, soilList.Soils.Count);
            Assert.AreEqual("Klei", soilList.Soils[0].Name);
            Assert.AreEqual(SoilType.Clay, soilList.Soils[0].SoilType);
            Assert.AreEqual(false, soilList.AquiferDictionary[soilList.Soils[0]]);
            Assert.AreEqual(Color.FromArgb(Convert.ToInt32(-16776961)), soilList.Soils[0].Color);
            Assert.AreEqual(0.2, soilList.Soils[0].DiameterD70);
            Assert.AreEqual(DistributionType.Uniform, soilList.Soils[0].BeddingAngleStochast.DistributionType);
            Assert.AreEqual("Zand", soilList.Soils[1].Name);
            Assert.AreEqual(Color.FromArgb(Convert.ToInt32(-65536)), soilList.Soils[1].Color);
            Assert.AreEqual(0.2, soilList.Soils[1].DiameterD70);
            Assert.AreEqual(true, soilList.AquiferDictionary[soilList.Soils[1]]);
            Assert.AreEqual(DistributionType.Uniform, soilList.Soils[1].BeddingAngleStochast.DistributionType);
        }

        [Test]
        public void CanReadPipingParameters()
        {
            soilbaseDB = new SoilbaseDB();
            soilbaseDB.Read(PipingTestDatabaseName);

            Assert.AreEqual(18, soilbaseDB.MaterialCount);

            Soil soil = soilbaseDB.GetSoil("KM1");
            Assert.AreEqual(0.0002, soil.DiameterD70, 0.0000000001);
            Assert.AreEqual(0.250, soil.WhitesConstant);
            Assert.AreEqual(37.0, soil.BeddingAngle);
            Assert.AreEqual(1.0e-8, soil.PermeabKx);
            soil = soilbaseDB.GetSoil("zand");
            Assert.AreEqual(0.0002, soil.DiameterD70, 0.0000000001);
            Assert.AreEqual(0.250, soil.WhitesConstant);
            Assert.AreEqual(37.0, soil.BeddingAngle);
            Assert.AreEqual(1.0e-4, soil.PermeabKx);
            soil = soilbaseDB.GetSoil("DKN4");
            Assert.AreEqual(0.000201, soil.DiameterD70, 0.0000000001);
            Assert.AreEqual(0.251, soil.WhitesConstant);
            Assert.AreEqual(38.0, soil.BeddingAngle);
            Assert.AreEqual(2.0e-8, soil.PermeabKx);
        }

        [Test]
        public void CanReadPipingProbabilisticParameters()
        {
            soilbaseDB = new SoilbaseDB();
            soilbaseDB.Read(PipingTestDatabaseName);

            Assert.AreEqual(18, soilbaseDB.MaterialCount);

            Soil soil = soilbaseDB.GetSoil("KM1");
            Assert.AreEqual(0.0002, soil.DiameterD70, 0.0000000001);
            Assert.AreEqual(0.250, soil.WhitesConstant);
            Assert.AreEqual(37.0, soil.BeddingAngle);
            Assert.AreEqual(1.0e-8, soil.PermeabKx);
            Assert.AreEqual(DistributionType.Deterministic, soil.DiameterD70Stochast.DistributionType);
            Assert.AreEqual(0.011*1e-6, soil.DiameterD70Stochast.Deviation);
            Assert.AreEqual(DistributionType.Normal, soil.PermeabKxStochast.DistributionType);
            Assert.AreEqual(0.012, soil.PermeabKxStochast.Deviation);
            Assert.AreEqual(DistributionType.LogNormal, soil.WhitesConstantStochast.DistributionType);
            Assert.AreEqual(0.013, soil.WhitesConstantStochast.Deviation);
            Assert.AreEqual(DistributionType.Deterministic, soil.BeddingAngleStochast.DistributionType);
            Assert.AreEqual(0.014, soil.BeddingAngleStochast.Deviation);
            soil = soilbaseDB.GetSoil("zand");
            Assert.AreEqual(0.0002, soil.DiameterD70, 0.0000000001);
            Assert.AreEqual(0.250, soil.WhitesConstant);
            Assert.AreEqual(37.0, soil.BeddingAngle);
            Assert.AreEqual(1.0e-4, soil.PermeabKx);
            Assert.AreEqual(DistributionType.Normal, soil.DiameterD70Stochast.DistributionType);
            Assert.AreEqual(0.021*1e-6, soil.DiameterD70Stochast.Deviation);
            Assert.AreEqual(DistributionType.LogNormal, soil.PermeabKxStochast.DistributionType);
            Assert.AreEqual(0.022, soil.PermeabKxStochast.Deviation);
            Assert.AreEqual(DistributionType.Deterministic, soil.WhitesConstantStochast.DistributionType);
            Assert.AreEqual(0.023, soil.WhitesConstantStochast.Deviation);
            Assert.AreEqual(DistributionType.Normal, soil.BeddingAngleStochast.DistributionType);
            Assert.AreEqual(0.024, soil.BeddingAngleStochast.Deviation);
        }

        [Test]
        public void CheckNameValuePairGetSet()
        {
            // this was moved here from SoilTest.cs - MDNLIB-418
            var expectedSoil = new Soil
                {
                    Name = "Sand", DiameterD70 = 1
                };
            Dictionary<string, string> nameValuePairs = SoilUtils.GetParametersAsNameValuePairs(expectedSoil);
            var actualSoil = new Soil();
            foreach (var soilDetail in nameValuePairs)
            {
                SoilUtils.SetParameterFromNameValuePair(actualSoil, soilDetail.Key, soilDetail.Value);
            }
            Assert.AreEqual(expectedSoil.DiameterD70, actualSoil.DiameterD70);

            expectedSoil.DiameterD70 = 20;
            nameValuePairs = SoilUtils.GetParametersAsNameValuePairs(expectedSoil);
            actualSoil = new Soil();
            foreach (var soilDetail in nameValuePairs)
            {
                SoilUtils.SetParameterFromNameValuePair(actualSoil, soilDetail.Key, soilDetail.Value);
            }
            Assert.AreEqual(expectedSoil.DiameterD70, actualSoil.DiameterD70);
        }

        [Test]
        public void DesignParametersHaveMovedToStochasts()
        {
            // as part of implementation of MDNLIB-418 some of the old soil parameters have been moved to the Stochasts
            // this test makes sure they are still read properly from an old MDB file (created manually with M-SoilBase)
            //
            //  old property name    test value  
            // DesignPartialCohesion  	(1.11)
            // DesignStdCohesion      	(0.11)
            // DesignPartialPhi         (2.22)
            // DesignStdPhi             (0.22)
            // DesignPartialStressTable (9.99)
            // DesignStdStressTable	    (0.99)
            // DesignPartialPOP	        (3.33)
            // DesignStdPOP		        (0.33)
            // designPartialRRatio	    (6.66)
            // DesignStdRRatio   	    (0.66)

            string testFile = @"TestFiles\DesignParameters.mdb";
            Assert.IsTrue(File.Exists(testFile));

            soilbaseDB = new SoilbaseDB();
            soilbaseDB.Read(testFile);

            var soil = soilbaseDB.GetSoils().Soils[0];
            Assert.AreEqual("TestSoil", soil.Name);

            Assert.AreEqual(1.11, soil.CohesionStochast.DesignFactor);
            Assert.AreEqual(0.11, soil.CohesionStochast.DesignDeviation);

            Assert.AreEqual(2.22, soil.FrictionAngleStochast.DesignFactor);
            Assert.AreEqual(0.22, soil.FrictionAngleStochast.DesignDeviation);

            Assert.AreEqual(9.99, soil.StressTableStochast.DesignFactor);
            Assert.AreEqual(0.99, soil.StressTableStochast.DesignDeviation);

            Assert.AreEqual(3.33, soil.POPStochast.DesignFactor);
            Assert.AreEqual(0.33, soil.POPStochast.DesignDeviation);

            Assert.AreEqual(6.66, soil.RRatioStochast.DesignFactor);
            Assert.AreEqual(0.66, soil.RRatioStochast.DesignDeviation);
        }

        [Test]
        [ExpectedException(typeof(CsvSoilsImporterException))]
        public void ErrorForEmptyFileNameOnImportSoilsFromCsv()
        {
            var mi = new CsvSoilsImporter();
            const string fileName = "";
            mi.ImportFromFile(fileName);
        }

        [Test]
        [ExpectedException(typeof(CsvSoilsImporterException))]
        public void ErrorForNonExistingFileNameOnImportSoilsFromCsv()
        {
            var mi = new CsvSoilsImporter();
            const string fileName = "ghygy";
            mi.ImportFromFile(fileName);
        }

        [Test]
        public void TestSoilbase()
        {
            soilbaseDB = new SoilbaseDB();
            soilbaseDB.Read(TestDatabaseName);

            Assert.AreEqual(37, soilbaseDB.MaterialCount);

            Soil soil = soilbaseDB.GetSoil("Kreftenheye (31)");
            Assert.AreEqual(SoilType.Clay, soil.SoilType);
            Assert.AreEqual(Color.FromArgb(255, 128, 128, 64), soil.Color);
            Assert.AreEqual(18.50, soil.AbovePhreaticLevel);
            Assert.AreEqual(18.50, soil.BelowPhreaticLevel);

            soil = soilbaseDB.GetSoil("Basisveen (9)");
            Assert.AreEqual(SoilType.Peat, soil.SoilType);
            Assert.AreEqual(Color.FromArgb(255, 0, 128, 64), soil.Color);
            Assert.AreEqual(11.00, soil.AbovePhreaticLevel);
            Assert.AreEqual(11.00, soil.BelowPhreaticLevel);

            soil = soilbaseDB.GetSoil("Pleistoceen (32)");
            Assert.AreEqual(SoilType.Sand, soil.SoilType);
            Assert.AreEqual(Color.FromArgb(255, 245, 255, 148), soil.Color);
            Assert.AreEqual(17.00, soil.AbovePhreaticLevel);
            Assert.AreEqual(20.00, soil.BelowPhreaticLevel);
        }

        private const string TestDatabaseName = @"TestFiles\Case A15.mdb";
        private const string PipingTestDatabaseName = @"TestFiles\soilmaterials.mdb";

        private SoilbaseDB soilbaseDB;
    }
}