using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Xml.Serialization;
using Deltares.DSoilModel.Data;
using Deltares.DSoilModel.Forms;
using Deltares.Geotechnics;
using Deltares.Geotechnics.IO;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.TestUtils;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;

namespace Tests
{
    internal class SosSoilLayer1DTest
    {
        private const string TestDataFolder = @"..\..\DSoilModel\Tests\TestData\";
        private const string TestOutputFolder = TestDataFolder + @"SoilModelDatabaseTest\";
        private bool oldIsDataEventPublishStopped;

        [TestFixtureSetUp]
        public void FixtureSetup()
        {
            oldIsDataEventPublishStopped = DataEventPublisher.IsDataEventPublishStopped;
            DataEventPublisher.IsDataEventPublishStopped = true;
            if (!Directory.Exists(TestOutputFolder))
            {
                Directory.CreateDirectory(TestOutputFolder);
            }
        }

        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
            DataEventPublisher.IsDataEventPublishStopped = oldIsDataEventPublishStopped;
        }

        [Test]
        public void DefaultConstructorDefaultValues()
        {
            var sosLayer = new SosSoilLayer1D();
            Assert.IsNull(sosLayer.MinimumTopLevel);
            Assert.IsNull(sosLayer.MaximumTopLevel);
            Assert.IsNullOrEmpty(sosLayer.RemarkTopLevel);
            Assert.IsNull(sosLayer.Soil);
            Assert.IsFalse(sosLayer.IsAquifer);
            Assert.AreEqual(0, sosLayer.TopLevel);
        }

        [Test]
        public void ReadSosLayerFromOldFileReturnsNullproperties()
        {
            using (var db = new SoilModelDatabase())
            {
                db.Open(Path.Combine(TestDataFolder, "SoilSegments_version_1_3_3.soil"));
                var profiles = db.ReadSoilProfiles1D<SosSoilLayer1D>();
                Assert.AreEqual(34, profiles.Count);
                foreach (var soilProfile in profiles)
                {
                    foreach (var layer in soilProfile.Layers)
                    {
                        var sosLayer = layer as SosSoilLayer1D;
                        Assert.NotNull(sosLayer);
                        Assert.IsNull(sosLayer.MinimumTopLevel);
                        Assert.IsNull(sosLayer.MaximumTopLevel);
                        Assert.IsNullOrEmpty(sosLayer.RemarkTopLevel);
                    }
                }
            }
        }

        [Test]
        public void StoreRestoreSosLayerInSoilModelDatabase()
        {
            // dummy profile with two SOS layers
            var sosProfile = new SoilProfile1D
            {
                Name = "TestSosProfile"
            };
            var sosProfiles = new List<SoilProfile1D>
                {
                    sosProfile
                };
            var sosLayer = new SosSoilLayer1D
            {
                Name = "TestSos1",
                TopLevel = -10,
                MaximumTopLevel = -9,
                MinimumTopLevel = -11,
                RemarkTopLevel = "remark testSos1",
                Soil = new Soil("TestSoil1", Color.Beige)
            };
            sosProfile.Layers.Add(sosLayer);
            sosLayer = new SosSoilLayer1D
            {
                Name = "TestSos2",
                TopLevel = -12,
                MaximumTopLevel = -11,
                MinimumTopLevel = -13,
                RemarkTopLevel = "remark testSos2",
                Soil = new Soil("TestSoil2", Color.Black)
            };
            sosProfile.Layers.Add(sosLayer);

            // store
            var database = new SoilModelDatabase();
            var fileName = TestOutputFolder + "TestSosSoilProfile1D.soil";
            database.New(fileName);
            database.WriteSoilProfile1Ds(sosProfiles);
            database.Close();

            //restore
            database = new SoilModelDatabase();
            database.Open(fileName);
            var sosProfilesCopy = database.ReadSoilProfiles1D<SosSoilLayer1D>();
            database.Close();

            var co = new CompareLogic();
            co.Config.MembersToIgnore = new List<String>
                {
                    "Id", "Name", "Soil", "Color", "SetCoordinate", "ChangeLog"
                };
            var result = co.Compare(sosProfilesCopy, sosProfiles);
            Assert.AreEqual(0, result.Differences.Count, "SOSProfileLayer1D fails comparison: " + result.DifferencesString);
        }

        [Test]
        [Category(Categories.Slow)]
        [Category(Categories.Performance)]
        public void PerformanceOfReadingWtiSosData()
        {
            // purpose of this test was to measure and improve the database performance while working on issue DSB-264
            string fileName = Path.Combine(TestHelper.GetDataPath(), @"D-Soil Model\SOS-data", "SosDatabase.soil");

            var timer = new Stopwatch();
            var database = new SoilModelDatabase();
            database.Open(fileName);

            // note: timings are estimated for build server

            // soils
            timer.Restart();
            var soils = database.ReadSoils().Soils;
            timer.Stop();
            Console.WriteLine("{0} seconds for reading soils", timer.Elapsed.Seconds);
            Assert.LessOrEqual(timer.Elapsed.Seconds, 25);
            Assert.AreEqual(42, soils.Count);

            // soilprofiles
            timer.Restart();
            var profiles = database.ReadSoilProfiles1D<SosSoilLayer1D>();
            timer.Stop();
            Console.WriteLine("{0} seconds for reading soil profiles", timer.Elapsed.Seconds);
            Assert.LessOrEqual(timer.Elapsed.Seconds, 20);

            // soilsegments
            timer.Restart();
            var segments = database.ReadSoilSegments();
            timer.Stop();
            Console.WriteLine("{0} seconds for reading soil segments", timer.Elapsed.Seconds);
            Assert.LessOrEqual(timer.Elapsed.Seconds, 10);

            // sanity check !
            Assert.AreEqual(5574, profiles.Count);
            foreach (var profile in profiles)
            {
                foreach (var layer in profile.Layers)
                {
                    Assert.IsInstanceOf(typeof(SosSoilLayer1D), layer);
                    var sosLayer = (SosSoilLayer1D)layer;
                    Assert.NotNull(sosLayer.MaximumTopLevel);
                    Assert.NotNull(sosLayer.MinimumTopLevel);
                }
            }
        }

        [Test]
        [Explicit]
        [Category(Categories.Slow)]
        public void GenerateWtiSosSoilFile()
        {
            // purpose here is to convert the WTI_SOS from CSV/SHP to .Soil format in a script, instead of having to use the D-SoilModel GUI for this

            // generate a .soil file containing the complete Wti SOS, and compare the input / output
            var sosFolder = Path.Combine(TestHelper.GetDataPath(), @"D-Soil Model\SOS-data");

            // import SOS data
            var project = new DSoilModelProject();
            var plugin = new DSoilModelPlugin(); // {Project = project};
            Console.WriteLine("reading soil profiles CSV....");
            project.ReadSoilProfiles1DFromFile(Path.Combine(sosFolder, "WTISOS_soilprofiles_short_code.csv"));

            Console.WriteLine("reading Segments CSV....");
            DSoilModelIO.ReadCsvSegmentsFromFileAndAddToProject(Path.Combine(sosFolder, "WTOSOS_segments.csv"), project);

            Console.WriteLine("reading Segments SHP....");
            DSoilModelIO.ReadSegmentShapefileAndAddToProject(Path.Combine(sosFolder, "WTI_SOS_alle_segmenten_def.shp"), project, "Segmentnr");

            // write database
            Console.WriteLine("writing to database....");
            var database = new SoilModelDatabase();
            database.New(Path.Combine(sosFolder, "SosDatabase.soil"));
            database.WriteSoils(project.Soils.Soils);
            database.WriteSoilProfile1Ds(project.SoilProfiles1D);
            database.WriteSoilSegments(project.SoilSegments);
            database.Close();

            // sanity check
            Console.WriteLine("sanity check....");
            database = new SoilModelDatabase();
            database.Open(Path.Combine(sosFolder, "SosDatabase.soil"));
            var profilesCopy = database.ReadSoilProfiles1D<SosSoilLayer1D>();

            // wipe layer names, irrelevant
            foreach (var profile in profilesCopy)
            {
                foreach (var layer in profile.Layers)
                {
                    layer.Name = "";
                }
            }

            var co = new CompareLogic();
            co.Config.ShowBreadcrumb = false;
            co.Config.CompareStaticFields = false;
            co.Config.CompareStaticProperties = false;
            co.Config.AttributesToIgnore = new List<Type> { typeof(XmlIgnoreAttribute) };
            co.Config.MembersToIgnore = new List<String>
                {
                    "Id", "Soil", "SetCoordinate", "Color"
                }; // including the soils here takes a looong time to prove nothing....
            var result = co.Compare(profilesCopy, project.SoilProfiles1D);
            Assert.AreEqual(0, result.Differences.Count, "SOSProfileLayer1D fails comparison: " + result.DifferencesString);
            Console.WriteLine("OK !");
        }
    }
}