// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the Dam Engine.
// 
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Interface;
using Deltares.DamEngine.Io;
using Deltares.DamEngine.Io.XmlOutput;
using DGeoSuite.Common;
using KellermanSoftware.CompareNetObjects;
using NUnit.Framework;
using ConversionHelper = Deltares.DamEngine.Interface.ConversionHelper;

namespace Deltares.DamEngine.TestHelpers;

public static class GeneralHelper
{
    public static int DetermineNumberOfCalculationErrors(List<LogMessage> calculationMessages)
    {
        var errorCount = 0;
        foreach (LogMessage logMessage in calculationMessages)
        {
            if (logMessage.MessageType is LogMessageType.Error or LogMessageType.FatalError)
            {
                errorCount++;
            }
        }

        return errorCount;
    }

    public static Output RunAfterInputValidation(string inputString, bool areResultsExpected = true, string outputFilename = "")
    {
        var engineInterface = new EngineInterface(inputString);
        return RunAfterInputValidation(engineInterface, areResultsExpected, outputFilename);
    }

    public static Output RunAfterInputValidation(EngineInterface engineInterface, bool areResultsExpected = true, string outputFilename = "")
    {
        // Validate input
        Assert.That(engineInterface.DamProjectData, Is.Not.Null);
        string validationMessages = engineInterface.Validate();
        var extraValidationMessage = "";
        if (outputFilename != "")
        {
            extraValidationMessage = ", see output xml in debugger";
        }

        Assert.That(validationMessages, Is.Null, "Validation should succeed but does not" + extraValidationMessage);

        // Run calculation
        string outputString = engineInterface.Run();
        Assert.That(outputString, Is.Not.Null);
        Output output = DamXmlSerialization.LoadOutputFromXmlString(outputString);
        if (outputFilename != "")
        {
            File.WriteAllText(outputFilename, outputString, Encoding.Unicode);
        }

        // Evaluate results
        if (!areResultsExpected)
        {
            Assert.That(output.Results.CalculationResults, Is.Null, "No results are expected");
            return output;
        }

        bool isNoResultAvailable;
        switch (engineInterface.DamProjectData.DamProjectType)
        {
            case DamProjectType.Design:
                isNoResultAvailable = output.Results.CalculationResults.IsNullOrEmpty();
                break;
            default:
                isNoResultAvailable = output.Results.OperationalOutputTimeSeries.IsNullOrEmpty();
                break;
        }

        if (!isNoResultAvailable)
        {
            CheckConsistencyOfAdaptGeometryResults(engineInterface, output.Results);
            return output;
        }

        var assertMessage = "No results available.";
        foreach (Message calcMessage in output.Results.CalculationMessages)
        {
            assertMessage = assertMessage + Environment.NewLine + calcMessage.Message1;
        }

        Assert.That(output.Results.CalculationResults, Is.Not.Null, assertMessage);
        return output;
    }

    private static void CheckConsistencyOfAdaptGeometryResults(EngineInterface engineInterface, OutputResults outputResults)
    {
        if (engineInterface.DamProjectData.DamProjectType == DamProjectType.Design &&  
            engineInterface.DamProjectData.DamProjectCalculationSpecification.AnalysisTypeForSerializationPurposeOnly == AnalysisType.AdaptGeometry)
        {
            var isIteratedFilePresent = false;

            foreach (DesignResult calculationResult in outputResults.CalculationResults)
            {
                bool isDesignSuccessful = calculationResult.CalculationResult == ConversionHelper.ConvertToOutputCalculationResult(CalculationResult.Succeeded) && 
                                          IsAdaptGeometrySuccessful(outputResults.CalculationMessages, calculationResult);
                double fosRequired = FetchRequiredFactor(engineInterface, calculationResult.ScenarioName, calculationResult.LocationName);
                double fosCalculated = FetchCalculatedFactor(engineInterface, calculationResult);
                if (isDesignSuccessful)
                {
                    string message = "After adapting the geometry, the calculated safety factor is less than the required safety factor " +
                                     $"for location '{calculationResult.LocationName}' and scenario '{calculationResult.ScenarioName}'. " +
                                     "This is unexpected.";
                    Assert.That(fosCalculated, Is.GreaterThanOrEqualTo(fosRequired), message);
                }
                else
                {
                    const string message = "As the design was not successful and had to stop, the calculated safety " +
                                           "factor should be less than the required safety factor but this is not the case.";
                    Assert.That(fosRequired, Is.GreaterThanOrEqualTo(fosCalculated), message);
                }

                string fileName = calculationResult.BaseFileName;
                // Note: only check for the iterated file if the design calculation was successful 
                isIteratedFilePresent = isIteratedFilePresent ||
                                        (!fileName.IsNullOrEmpty() && fileName.Contains("Ite(") && !fileName.Contains("Ite(1)"))
                                        || !isDesignSuccessful;
            }

            // The iterated file is created only for the stability mechanism (not for piping) to be opened in D-Stability
            if (engineInterface.DamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType != FailureMechanismSystemType.Piping)
            {
                Assert.That(isIteratedFilePresent, Is.True, "The AnalyseType is set to AdaptGeometry in the input, however the geometry was " +
                                                            "not adapted in any location. Either set the AnalysisType to NoAdaptation or " +
                                                            "increase the required safety factor.");
            }
        }
    }

    private static bool IsAdaptGeometrySuccessful(Message[] messages, DesignResult results)
    {
        return !(from message in messages
                 let location = "Location '" + results.LocationName + "'"
                 let profile = "subsoil scenario '" + results.ProfileName + "'"
                 let scenario = "design scenario '" + results.ScenarioName + "'"
                 where message.Message1.Contains("The design was not successful.") &&
                       message.Message1.Contains(location) && message.Message1.Contains(profile) &&
                       message.Message1.Contains(scenario)
                 select message).Any();
    }

    private static double FetchRequiredFactor(EngineInterface engineInterface, string scenarioName, string locationName)
    {
        foreach (Location location in engineInterface.DamProjectData.Dike.Locations)
        {
            foreach (DesignScenario scenario in location.Scenarios)
            {
                if (location.Name == locationName && scenario.LocationScenarioID == scenarioName)
                {
                    return engineInterface.DamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType switch
                    {
                        FailureMechanismSystemType.StabilityInside => scenario.RequiredSafetyFactorStabilityInnerSlope,
                        FailureMechanismSystemType.StabilityOutside => scenario.RequiredSafetyFactorStabilityOuterSlope,
                        FailureMechanismSystemType.Piping => scenario.RequiredSafetyFactorPiping,
                        _ => throw new ArgumentOutOfRangeException()
                    };
                }
            }
        }

        return 999;
    }

    private static double FetchCalculatedFactor(EngineInterface engineInterface, DesignResult results)
    {
        switch (engineInterface.DamProjectData.DamProjectCalculationSpecification.CurrentSpecification.FailureMechanismSystemType)
        {
            case FailureMechanismSystemType.StabilityInside:
            case FailureMechanismSystemType.StabilityOutside:
                return results.StabilityDesignResults.SafetyFactor;
            case FailureMechanismSystemType.Piping:
                switch (engineInterface.DamProjectData.DamProjectCalculationSpecification.CurrentSpecification.PipingModelType)
                {
                    case PipingModelType.Wti2017:
                        return results.PipingDesignResults.Wti2017BackwardErosionFactor;
                    case PipingModelType.Bligh:
                        return results.PipingDesignResults.BlighFactor;
                }

                break;
            default:
                throw new ArgumentOutOfRangeException();
        }

        return 0;
    }

    public static void CompareDesignOutput(Output expected, Output actual)
    {
        StripCalculationSubDir(expected);
        StripCalculationSubDir(actual);
        CompareOutput(expected, actual);
    }

    private static void StripCalculationSubDir(Output expected)
    {
        foreach (DesignResult result in expected.Results.CalculationResults)
        {
            result.CalculationSubDir = "";
        }
    }
    
    public static void CompareOutput(Output expected, Output actual)
    {
        var compare = new CompareLogic
        {
            Config =
            {
                MaxDifferences = 100
            }
        };
        ComparisonResult result = compare.Compare(expected, actual);
        Assert.That(result.Differences, Is.Empty, "Differences found read/write Output object");
    }

    public static void RemoveTestWorkingDirectory(string testWorkingFolder)
    {
        if (Directory.Exists(testWorkingFolder))
        {
            const bool recursive = true;
            Directory.Delete(testWorkingFolder, recursive);
        }
    }

    public static Output RunMultiCoreWithXmlInputFile(string mapTestFiles, DamProjectType damProjectType,
                                                      int maxCores, string calcDir, string inputFilename, string outputFilename, 
                                                      bool justOneScenario = false, bool expectedNoErrors = true)
    {
        var processorCount = Environment.ProcessorCount;
        if (maxCores > processorCount)
        {
            Assert.Ignore($"The number of cores requested ({maxCores}) is higher than the number of available cores ({processorCount}).");
        }
        if (Directory.Exists(calcDir))
        {
            Directory.Delete(calcDir, true); // delete previous results
        }
        Directory.CreateDirectory(calcDir);

        string fullInputFilename = Path.Combine(mapTestFiles, inputFilename);
        string inputString = File.ReadAllText(fullInputFilename);
        inputString = XmlAdapter.ChangeValueInXml(inputString, "ProjectPath", ""); // Current directory will be used
        inputString = XmlAdapter.ChangeValueInXml(inputString, "CalculationMap", calcDir); // Current directory will be used
        inputString = XmlAdapter.ChangeValueInXml(inputString, "MaxCalculationCores", maxCores.ToString());
        var engineInterface = new EngineInterface(inputString);
        if (justOneScenario)
        {
            engineInterface.DamProjectData.Dike.ClearLocationScenariosExceptFirst();
        }
        Assert.That(engineInterface.DamProjectData, Is.Not.Null);
        Assert.That(engineInterface.DamProjectData.DamProjectType, Is.EqualTo(damProjectType));

        Output output = GeneralHelper.RunAfterInputValidation(engineInterface, true, outputFilename);
        if (expectedNoErrors)
        {
            int errorCount = GeneralHelper.DetermineNumberOfCalculationErrors(engineInterface.DamProjectData.CalculationMessages);
            Assert.That(errorCount, Is.EqualTo(0), "There should be no errors during the calculation.");
        }
        return output;
    }
    
    
}