using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using Deltares.Geotechnics;
using NUnit.Framework;

namespace Deltares.Soilbase.Tests
{
    [TestFixture]
    public class SoilbaseWriterTest
    {
        [SetUp]
        public void TestSetup() {}

        [TearDown]
        public void TestTearDown() {}

        [Test]
        public void StoreMaterialName_NameExistsInLookup_NameIsNotInsertedIntoMaterialTable()
        {
            // setup
            string dbFileName = GetDbFileName();
            var db = Database.Create(dbFileName);
            var writer = new SoilbaseWriter(db);

            const string name = "Test";
            const int id = 0;
            var lookup = new Dictionary<string, int>
                {
                    {
                        name, id
                    }
                };

            // call
            writer.StoreMaterial(lookup, name);

            // tests
            Assert.IsTrue(lookup.Count == 1);
        }

        [Test]
        public void StoreMaterialName_NameExists_NameIsNotInsertedIntoMaterialTable()
        {
            // setup
            string dbFileName = GetDbFileName();
            var db = Database.Create(dbFileName);
            var writer = new SoilbaseWriter(db);

            var lookup = new Dictionary<string, int>();
            const string name = "Test";

            // call
            writer.StoreMaterial(lookup, name);
            writer.StoreMaterial(lookup, name); // store twice (should not work)

            // tests
            Assert.IsTrue(lookup.Count == 1);

            // generate new lookup from table to see if no record is added
            var dictionary = writer.GetMaterialIdLookupTable();
            Assert.IsTrue(dictionary.ContainsKey(name));
            Assert.IsTrue(dictionary.Count == 1);
        }

        [Test]
        public void StoreMaterialName_NameNotExists_NameInsertedIntoMaterialTable()
        {
            // setup
            string dbFileName = GetDbFileName(commonTestDb);
            var db = new Database(dbFileName);
            var writer = new SoilbaseWriter(db);

            // call
            var lookup = new Dictionary<string, int>();
            const string materialName = "Test";
            writer.StoreMaterial(lookup, materialName);

            // tests
            var dictionary = writer.GetMaterialIdLookupTable();
            Assert.IsTrue(dictionary.ContainsKey(materialName));
        }

        [Test]
        public void StoreParameterName_NameExistsInLookup_NameIsNotInsertedIntoParameterNameTable()
        {
            // setup
            string dbFileName = GetDbFileName(commonTestDb);
            var db = new Database(dbFileName);
            var updater = new SoilbaseWriter(db);

            const string name = "Test";
            const int id = 0;
            var lookup = new Dictionary<string, int>
                {
                    {
                        name, id
                    }
                };

            // call
            updater.StoreParameterName(lookup, name);

            // tests
            Assert.IsTrue(lookup.Count == 1);
        }

        [Test]
        public void StoreParameterName_NameExists_NameIsNotInsertedIntoParameterNameTable()
        {
            // setup
            string dbFileName = GetDbFileName(commonTestDb);
            var db = new Database(dbFileName);
            var writer = new SoilbaseWriter(db);

            // call
            var lookup = new Dictionary<string, int>();
            const string name = "Test";
            writer.StoreParameterName(lookup, name);
            writer.StoreParameterName(lookup, name); // store twice 

            // tests            
            Assert.IsTrue(lookup.Count == 1);

            // generate new lookup from table to see if no record is added
            var dictionary = writer.GetParameterNameIdLookupTable();
            Assert.IsTrue(dictionary.ContainsKey(name));
            Assert.IsTrue(dictionary.Count == 1);
        }

        [Test]
        public void StoreParameterName_NameNotExists_NameInsertedIntoParameterNameTable()
        {
            // setup
            string dbFileName = GetDbFileName();
            var db = Database.Create(dbFileName);
            var writer = new SoilbaseWriter(db);

            // call
            var lookup = new Dictionary<string, int>();
            const string parameterName = "Test";
            writer.StoreParameterName(lookup, parameterName);

            // tests
            var dictionary = writer.GetParameterNameIdLookupTable();
            Assert.IsTrue(dictionary.ContainsKey(parameterName));
        }

        [Test]
        public void StoreParameterValue_ValueExists_ValueUpdatedInParameterValuesTable()
        {
            // setup
            string dbFileName = GetDbFileName();
            var db = Database.Create(dbFileName);
            var updater = new SoilbaseWriter(db);

            // insert a material and get the id
            var materialLookupTable = updater.GetMaterialIdLookupTable();
            const string soilName = "zandtype001";
            updater.StoreMaterial(materialLookupTable, soilName);
            var materialId = materialLookupTable[soilName];

            // insert a parameter name and get the id
            var paramNameLookupTable = updater.GetParameterNameIdLookupTable();
            const string paramName = "parameter999";
            updater.StoreParameterName(paramNameLookupTable, paramName);
            var paramId = paramNameLookupTable[paramName];

            var parameterValuesIdLookup = new Dictionary<Tuple<int, int>, int>();

            // assure that the value exists in the db
            updater.StoreParameterValue(materialId, paramId, parameterValuesIdLookup, 0);

            // call
            const double parameterValue = 999;
            updater.StoreParameterValue(materialId, paramId, parameterValuesIdLookup, parameterValue);

            // tests
            Assert.IsTrue(parameterValuesIdLookup.Count == 1);

            // generate new lookup from table to see if no record is added
            var dictionary = updater.GetParameterValueIdLookupTable();
            var key = new Tuple<int, int>(materialId, paramId);
            Assert.IsTrue(dictionary.ContainsKey(key));
            Assert.IsTrue(dictionary.Count == 1);

            var table = db.GetDataTable(SoilbaseDB.ParameterValuesTableName);
            var parameterValues = table.TableToDictionary(
                row => row.Field<int>(SoilbaseDB.ParameterValuesColumnID),
                row => row.Field<double>(SoilbaseDB.ParameterValuesColumnValue));

            int id = parameterValuesIdLookup[key];
            Assert.AreEqual(parameterValue, parameterValues[id]);
        }

        [Test]
        public void StoreParameterValue_ValueNotExists_ValueInsertedIntoParameterValuesTable()
        {
            // setup
            string dbFileName = GetDbFileName();
            var db = Database.Create(dbFileName);
            var updater = new SoilbaseWriter(db);

            // insert a material and get the id
            var materialLookupTable = updater.GetMaterialIdLookupTable();
            const string soilName = "zandtype001";
            updater.StoreMaterial(materialLookupTable, soilName);
            var materialId = materialLookupTable[soilName];

            // insert a parameter name and get the id
            var paramNameLookupTable = updater.GetParameterNameIdLookupTable();
            const string paramName = "parameter999";
            updater.StoreParameterName(paramNameLookupTable, paramName);
            var paramId = paramNameLookupTable[paramName];

            var parameterValuesIdLookup = new Dictionary<Tuple<int, int>, int>();

            // call           
            const double parameterValue = 999;
            updater.StoreParameterValue(materialId, paramId, parameterValuesIdLookup, parameterValue);

            // tests
            Assert.IsTrue(parameterValuesIdLookup.Count == 1);

            var table = db.GetDataTable(SoilbaseDB.ParameterValuesTableName);
            var parameterValues = table.TableToDictionary(
                row => row.Field<int>(SoilbaseDB.ParameterValuesColumnID),
                row => row.Field<double>(SoilbaseDB.ParameterValuesColumnValue));

            var key = new Tuple<int, int>(materialId, paramId);
            int id = parameterValuesIdLookup[key];
            Assert.AreEqual(parameterValue, parameterValues[id]);
        }

        private const string databaseTestFolder = @"TestData\SoilbaseUpdaterTests";
        private const string commonTestDb = "SoilbaseUpdateTestDB.mdb";

        /// <summary>
        /// Gets a random db test file name.
        /// </summary>
        /// <returns></returns>
        private string GetDbFileName()
        {
            var guid = Guid.NewGuid().ToString().Replace("-", "");
            return GetDbFileName(guid + ".mdb");
        }

        private string GetDbFileName(string name)
        {
            return Path.Combine(databaseTestFolder, name);
        }

        [TestFixtureSetUp]
        public void FixtureSetup()
        {
            if (Directory.Exists(databaseTestFolder))
            {
                Directory.Delete(databaseTestFolder, true);
            }

            Directory.CreateDirectory(databaseTestFolder);

            Database.Create(GetDbFileName(commonTestDb));
        }

        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
            if (Directory.Exists(databaseTestFolder))
            {
                // Directory.Delete(databaseTestFolder, true);
            }
        }

        public void Insert_Scenario_Result()
        {
            var soil = new Soil();
            SoilUtils.GetDatabaseParameterList(soil);
        }
    }
}