using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using Deltares.Dam.Data;
using Deltares.Dam.TestHelper;
using Deltares.Standard.IO;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    /// <summary>
    /// Run comparison tests for selected kernels
    /// </summary>
    public class ComparisonTestRunner
    {
        private static object sync = new object();
        private const int maxCalculationCores = 8;

        private const string cmstabProgramPath = ".\\DGeoStability.exe";
        public static string DataPath { get; set; }
        public static DamIntegrationTestTolerance Tolerances { get; set; }
        public static string[] PropertiesToCheck { get; set; }
        public static string DamWtiTestReportsDir { get; set; }
        public static int projectCount = 0;

        /// <summary>
        /// Gets the path to the data directory in the Deltares development space for DelftGeoSystems
        /// </summary>
        /// <returns></returns>
        public static string GetDataPath()
        {
            string basePath = AppDomain.CurrentDomain.BaseDirectory;
            while (!basePath.ToLower().EndsWith("src"))
            {
                basePath = Directory.GetParent(basePath).ToString();
            }

            basePath = Directory.GetParent(basePath).ToString();
            string dataPath = System.IO.Path.Combine(basePath, "data");
            return dataPath;
        }

        /// <summary>
        /// Gets the path to the data directory in the Deltares development space for DelftGeoSystems
        /// </summary>
        /// <returns></returns>
        public static string GetBinReleasePath()
        {
            string basePath = AppDomain.CurrentDomain.BaseDirectory;
            while (!basePath.ToLower().EndsWith("src"))
            {
                basePath = Directory.GetParent(basePath).ToString();
            }
            string binReleasePath = System.IO.Path.Combine(basePath, "bin", "Release");
            return binReleasePath;
        }

        /// <summary>
        /// Runs the comparison test.
        /// </summary>
        /// <param name="damProjectFilename">Name of the dir.</param>
        /// <param name="locationsToCalculate">The locations to calculate. If null then all locations are selected</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <param name="textWriter">The text writer.</param>
        /// <param name="isDataFromDataDir">if set to <c>true</c> [is data from data dir].</param>
        /// <returns></returns>
        public List<string> RunStabilityComparisonTest(string damProjectFilename, IList<string> locationsToCalculate, IList<StabilityKernelType> selectedStabilityKernelTypes,
            TextWriter textWriter, bool isDataFromDataDir = true)
        {
            lock (sync)
            {
                projectCount++;

                //prepare summary text for artifacts on buildserver
                var testMessagesNotOk = new List<string>();
                Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
                var allMessages = new List<string>();
                DateTime time = DateTime.Now;
                allMessages.Add(String.Format("Test start: {0}", time.ToShortDateString() + "  " + time.ToShortTimeString()));

                var actualResults = new Dictionary<StabilityKernelType, IList<CsvExportData>>();
                foreach (var selectedStabilityKernelType in selectedStabilityKernelTypes)
                {
                    List<List<CsvExportData>> stabilityResultsActual = CalculateStabilityProject(selectedStabilityKernelType, damProjectFilename, locationsToCalculate);

                    List<CsvExportData> actual = CreateResultsList(stabilityResultsActual);
                    actualResults[selectedStabilityKernelType] = actual;

                    allMessages.Add("Stability kernel type: " + selectedStabilityKernelType.ToString());

                    //compare the calculation results of the original stability kernel to the new kernel
                    //foreach (var parameter in PropertiesToCheck)
                    //{
                    //    for (int i = 0; i < actual.Count; i++)
                    //    {
                    //        CompareCalculationResults(expected[i], actual[i], parameter, testMessagesNotOk, allMessages);
                    //    }
                    //}

                    //write failed results to console
                    foreach (var message in testMessagesNotOk)
                    {
                        System.Console.WriteLine(@"Test failed: " + message);
                    }
                    //when this assertion is carried out, some tests will fail and the results will not be persisted to files
                    //Assert.AreEqual(0, testMessagesNotOk.Count, "One or more comparison tests failed.");
                }
                //write all results to txt file
                Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
                time = DateTime.Now;
                allMessages.Add(String.Format("Test end: {0}", time.ToShortDateString() + "  " + time.ToShortTimeString()));
                WriteToTextFile(damProjectFilename, allMessages, textWriter);

                OutputReport(damProjectFilename, selectedStabilityKernelTypes, actualResults);

                return testMessagesNotOk;
            }
        }

        /// <summary>
        /// Outputs the report.
        /// </summary>
        /// <param name="damProjectFilename">The dam project filename.</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <param name="actualResults">The actual results.</param>
        private void OutputReport(string damProjectFilename, IList<StabilityKernelType> selectedStabilityKernelTypes,
            Dictionary<StabilityKernelType, IList<CsvExportData>> actualResults)
        {
            foreach (var selectedStabilityKernelType in selectedStabilityKernelTypes)
            {
                // Export actual data to csv
                var exportName = CreateExportName(damProjectFilename, selectedStabilityKernelType);
                ExportDataToCsv(exportName, actualResults[selectedStabilityKernelType], ".csv");
            }

            OutputReportPerProperty(damProjectFilename, selectedStabilityKernelTypes, actualResults);

            OutputReportPerKernel(damProjectFilename, selectedStabilityKernelTypes, actualResults);
        }

        /// <summary>
        /// Outputs the report per kernel.
        /// </summary>
        /// <param name="damProjectFilename">The dam project filename.</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <param name="actualResults">The actual results.</param>
        private void OutputReportPerKernel(string damProjectFilename, IList<StabilityKernelType> selectedStabilityKernelTypes, 
            Dictionary<StabilityKernelType, IList<CsvExportData>> actualResults)
        {
            string header;
            string reportFilename;
            var allResultsString = new List<string>();
            // Write header
            header = "Location;";
            foreach (var selectedStabilityKernelType in selectedStabilityKernelTypes)
            {
                header = header + HeadersForKernelType(selectedStabilityKernelType);
            }
            allResultsString.Add(header);
            // Write results
            IList<CsvExportData> firstKernelResults = actualResults[selectedStabilityKernelTypes.First()];
            for (int i = 0; i < firstKernelResults.Count; i++)
            {
                string resultsString = firstKernelResults[i].LocationName + ";";
                foreach (var selectedStabilityKernelType in selectedStabilityKernelTypes)
                {
                    resultsString = resultsString + ResultsForKernelType(selectedStabilityKernelType, actualResults[selectedStabilityKernelType][i]);
                }
                allResultsString.Add(resultsString);
            }

            reportFilename = CreateReportName(damProjectFilename) + " - Comparison per kernel.csv";
            using (var tw = new StreamWriter((string) reportFilename))
            {
                foreach (var line in allResultsString)
                {
                    tw.WriteLine(line);
                }
                tw.Close();
            }
        }

        /// <summary>
        /// Outputs the report per property.
        /// </summary>
        /// <param name="damProjectFilename">The dam project filename.</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <param name="actualResults">The actual results.</param>
        private void OutputReportPerProperty(string damProjectFilename, IList<StabilityKernelType> selectedStabilityKernelTypes, 
            Dictionary<StabilityKernelType, IList<CsvExportData>> actualResults)
        {
            string reportFilename;
            // Write overview of results
            var allResultsString = new List<string>();

            // Write header
            string header = "Location;";
            foreach (var property in PropertiesToCheck)
            {
                header = header + HeadersForProperty(property, selectedStabilityKernelTypes);
            }
            allResultsString.Add(header);
            // Write results
            IList<CsvExportData> firstKernelResults = actualResults[selectedStabilityKernelTypes.First()];
            for (int i = 0; i < firstKernelResults.Count; i++)
            {
                string resultsString = firstKernelResults[i].LocationName + ";";
                foreach (var property in PropertiesToCheck)
                {
                    resultsString = resultsString + ResultsForProperty(property, selectedStabilityKernelTypes, actualResults, i);
                }
                allResultsString.Add(resultsString);
            }
            reportFilename = CreateReportName(damProjectFilename) + " - Comparison per property.csv";
            using (var tw = new StreamWriter((string) reportFilename))
            {
                foreach (var line in allResultsString)
                {
                    tw.WriteLine(line);
                }
                tw.Close();
            }
        }

        /// <summary>
        /// Results for property.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <param name="actualResults">The actual results.</param>
        /// <param name="index">The index.</param>
        /// <returns></returns>
        private string ResultsForProperty(string property , IList<StabilityKernelType> selectedStabilityKernelTypes, 
            Dictionary<StabilityKernelType, IList<CsvExportData>> actualResults, int index)
        {
            string resultString = "";
            foreach (var stabilityKernelType in selectedStabilityKernelTypes)
            {
                resultString = resultString + String.Format("{0:0.0000}", GetPropertyValue(actualResults[stabilityKernelType][index], property))+ ";";
            }
            return resultString;
        }

        /// <summary>
        /// Headerses for property.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="selectedStabilityKernelTypes">The selected stability kernel types.</param>
        /// <returns></returns>
        private string HeadersForProperty(string property, IList<StabilityKernelType> selectedStabilityKernelTypes)
        {
            string header = "";
            foreach (var stabilityKernelType in selectedStabilityKernelTypes)
            {
                header = header + stabilityKernelType + "-" + property + ";";
            }
            return header;
        }

        /// <summary>
        /// Headerses the type of for kernel.
        /// </summary>
        /// <param name="stabilityKernelType">Type of the stability kernel.</param>
        /// <returns></returns>
        private string HeadersForKernelType(StabilityKernelType stabilityKernelType)
        {
            string header = "";
            foreach (var property in PropertiesToCheck)
            {
                header = header + stabilityKernelType + "-" + property + ";";
            }
            return header;
        }

        /// <summary>
        /// Resultses the type of for kernel.
        /// </summary>
        /// <param name="stabilityKernelType">Type of the stability kernel.</param>
        /// <param name="results">The actual results.</param>
        /// <returns></returns>
        private string ResultsForKernelType(StabilityKernelType stabilityKernelType, CsvExportData results)
        {
            string resultString = "";
            foreach (var property in PropertiesToCheck)
            {
                var result = String.Format("{0:0.0000}", GetPropertyValue(results, property));
                resultString = resultString + result + ";";
            }
            return resultString;
        }

        /// <summary>
        /// Creates the results list.
        /// </summary>
        /// <param name="calculationResults">The calculation results.</param>
        /// <returns></returns>
        private List<CsvExportData> CreateResultsList(List<List<CsvExportData>> calculationResults)
        {
            List<CsvExportData> resultList = new List<CsvExportData>();
            foreach (var result in calculationResults)
            {
                resultList.AddRange(result);
            }
            return resultList;
        }

        /// <summary>
        /// Creates the name of the export.
        /// </summary>
        /// <param name="projectFilename">Name of the project</param>
        /// <param name="selectedStabilityKernelType">Type of the selected stability kernel.</param>
        /// <returns></returns>
        private static string CreateExportName(string projectFilename, StabilityKernelType selectedStabilityKernelType)
        {
            string filename = String.Format("{0:00} - {1} - {2}", projectCount, Path.GetFileNameWithoutExtension(projectFilename), selectedStabilityKernelType);
            string exportName = Path.Combine(DamWtiTestReportsDir, filename);
            return exportName;
        }

        /// <summary>
        /// Creates the name of the report.
        /// </summary>
        /// <param name="projectFilename">The project filename.</param>
        /// <returns></returns>
        private static string CreateReportName(string projectFilename)
        {
            string filename = String.Format("{0:00} - {1}", projectCount, Path.GetFileNameWithoutExtension(projectFilename));
            string exportName = Path.Combine(DamWtiTestReportsDir, filename);
            return exportName;
        }

        /// <summary>
        /// Gets the maximum allowed calculation cores for selected stability kernel.
        /// </summary>
        /// <param name="selectedStabilityKernelType">Type of the selected stability kernel.</param>
        /// <returns></returns>
        private static int GetMaxAllowedCalculationCoresForKernel(StabilityKernelType selectedStabilityKernelType)
        {
            switch (selectedStabilityKernelType)
            {
                case StabilityKernelType.DamClassicDotNet:
                    return 1;                    
                case StabilityKernelType.AdvancedDotNet:
                    return 1;                    
                default:
            return maxCalculationCores;
            }
        }
        /// <summary>
        /// Calculates the stability using specified kernels.
        /// </summary>
        /// <param name="selectedStabilityKernelType">Type of the selected stability kernel.</param>
        /// <param name="projectFilename">Name of the directory.</param>
        /// <param name="locationsToCalculate">The locations to calculate. If null then all locations are selected</param>
        /// <returns></returns>
        private static List<List<CsvExportData>> CalculateStabilityProject(StabilityKernelType selectedStabilityKernelType, string projectFilename, IList<string> locationsToCalculate)
        {
            DateTime timeStart = DateTime.Now;
            DamProject.ProjectWorkingPathLocation = ProjectPathLocation.InProjectMap;
            using (DamProjectData damProjectData = ReadDamProjectData(projectFilename))
            {
                if (damProjectData == null)
                {
                    Assert.IsNotNull(damProjectData, "DAM project not loaded correct");
                }

                // setup calculation options
                damProjectData.DamProjectType = DamProjectType.Design;
                Dike dike = damProjectData.WaterBoard.Dikes[0];

                // specify calculation
                if (damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Count < 1)
                {
                    damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Clear();
                    DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);
                }
                damProjectData.DamProjectCalculationSpecification.CurrentSpecification =
                    damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications[0];

                // If no locations specified, select all locations
                if (locationsToCalculate == null)
                {
                    locationsToCalculate = damProjectData.Locations.Select(location => location.Name).ToList();
                }
                // Select the specificied locations
                DamIntegrationTestHelper.SpecifyLocationsToCalculate(damProjectData, locationsToCalculate);

                // Create scenarios for selected locations
                List<Scenario> scenarios = new List<Scenario>();
                foreach (var locationJob in damProjectData.LocationJobs)
                {
                    if (locationJob.Run.HasValue && locationJob.Run.Value)
                    {
                        scenarios.AddRange(locationJob.Location.Scenarios);
                    }
                }

                // specify stability kernel type and waternet creator type
                System.Console.WriteLine(@"Selected calculation kernel type: " + selectedStabilityKernelType.ToString());
                damProjectData.DamProjectCalculationSpecification.SelectedStabilityKernelType = selectedStabilityKernelType;

                // setup project calculator with other stability kernel
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.ProjectDataDirectory = Path.GetDirectoryName(projectFilename);
                if (!String.IsNullOrEmpty(damProjectCalculator.ProjectDataDirectory))
                {
                    damProjectCalculator.ProjectDataDirectory += Path.DirectorySeparatorChar;
                }
                
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(projectFilename, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                damProjectCalculator.MaxCalculationCores = GetMaxAllowedCalculationCoresForKernel(selectedStabilityKernelType);
                //call
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, scenarios);

                //calculation time
                var timeSpan = DateTime.Now.Subtract(timeStart);
                string newKernelTime = String.Format(@"calculation time kernel ({0}): {1:0.0} seconds", selectedStabilityKernelType, timeSpan.TotalSeconds);
                System.Console.WriteLine(newKernelTime);

                return allCalculationresults;
            }
        }


        /// <summary>
        /// Reads the dam project data.
        /// </summary>
        /// <param name="projectFilename">The dam file location.</param>
        /// <returns></returns>
        private static DamProjectData ReadDamProjectData(string projectFilename)
        {
            Assert.AreEqual(true, File.Exists(projectFilename));
            // Read dikering
            var damProjectData = ProjectLoader.LoadProjectData(projectFilename);
            return damProjectData;
        }

        /// <summary>
        /// Exports the data to CSV.
        /// </summary>
        /// <param name="projectFilename">Name of the dir.</param>
        /// <param name="csvExportData">The CSV export data.</param>
        /// <param name="resultType">Type of the result.</param>
        private void ExportDataToCsv(string projectFilename, IList<CsvExportData> csvExportData, string resultType)
        {
            new TestResultsWriter().ExportDataToCsv(DamWtiTestReportsDir, projectFilename, csvExportData, resultType);
        }

        /// <summary>
        /// Writes to text file.
        /// </summary>
        /// <param name="projectFilename">Name of the dir.</param>
        /// <param name="allMessages">All messages.</param>
        /// <param name="textWriter">The text writer.</param>
        private void WriteToTextFile(string projectFilename, List<string> allMessages, TextWriter textWriter)
        {
            new TestResultsWriter().WriteToTextFile(projectFilename, allMessages, textWriter);
        }

        /// <summary>
        /// Compares the calculation results.
        /// </summary>
        /// <param name="calculationResultsOriginal">The calculation results original.</param>
        /// <param name="calculationResultsNewKernel">The calculation results new kernel.</param>
        /// <param name="propertyToCheck">The property to check.</param>
        /// <param name="messagesNotOk">The messages not ok.</param>
        /// <param name="allMessages">All messages.</param>
        private void CompareCalculationResults(CsvExportData calculationResultsOriginal,
            CsvExportData calculationResultsNewKernel, string propertyToCheck, List<string> messagesNotOk,
            List<string> allMessages)
        {
            var valueActual = GetPropertyValue(calculationResultsNewKernel, propertyToCheck);
            var valueExpected = GetPropertyValue(calculationResultsOriginal, propertyToCheck);
            var toleranceValue = GetToleranceValue(Tolerances, propertyToCheck);
            if (toleranceValue == null)
            {
                toleranceValue = 0.01;
            }
            if (valueExpected == null || valueActual == null)
            {
                string message = "Property " + propertyToCheck + " that was compared has a null value as result.";
                messagesNotOk.Add(message);
            }
            else 
            {
                double expectedValue = (double) valueExpected;
                double actualValue = (double) valueActual;
                bool ok = Math.Abs((double) (expectedValue - actualValue)) <
                          toleranceValue;
                string message = propertyToCheck + " - Expected: " + expectedValue.ToString("F3") + " " +
                                 propertyToCheck + " - Actual: " + actualValue.ToString("F3");
                allMessages.Add(message);
                System.Console.WriteLine(message);
                if (!ok)
                {
                    messagesNotOk.Add(message);
                }
            }
        }

        /// <summary>
        /// Gets the property value.
        /// </summary>
        /// <param name="calculationResults">The calculation results.</param>
        /// <param name="propertyToCheck">The property to check.</param>
        /// <returns></returns>
        private static double? GetPropertyValue(object calculationResults, string propertyToCheck)
        {
            double? valueExpected = null;
            Type type = calculationResults.GetType();
            BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
            PropertyInfo[] properties = type.GetProperties(flags);
            foreach (var propertyInfo in properties)
            {
                if (propertyInfo.Name == propertyToCheck)
                {
                    valueExpected = (double?) propertyInfo.GetValue(calculationResults, null);
                }
            }
            return valueExpected;
        }

        /// <summary>
        /// Gets the tolerance value.
        /// </summary>
        /// <param name="tolerances">The tolerances.</param>
        /// <param name="propertyToCheck">The property to check.</param>
        /// <returns></returns>
        private static double? GetToleranceValue(object tolerances, string propertyToCheck)
        {
            double? toleranceValue = null;
            Type type = tolerances.GetType();
            BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
            PropertyInfo[] properties = type.GetProperties(flags);
            foreach (var propertyInfo in properties)
            {
                if (propertyInfo.Name.Contains(propertyToCheck))
                {
                    toleranceValue = (double?) propertyInfo.GetValue(tolerances, null);
                }
            }
            return toleranceValue;
        }
    }
}