// 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.Data;
using Deltares.DamEngine.Calculators.DikesDesign;
using Deltares.DamEngine.Calculators.KernelWrappers.Common;
using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces;
using Deltares.DamEngine.Calculators.Properties;
using Deltares.DamEngine.Calculators.Uplift;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamPiping.BlighCalculator;

namespace Deltares.DamEngine.Calculators.KernelWrappers.DamPipingBligh;

/// <summary>
/// Wrapper around Bligh piping kernel
/// </summary>
/// <seealso cref="Deltares.DamEngine.Calculators.KernelWrappers.Interfaces.IKernelWrapper" />
public class DamPipingBlighKernelWrapper : IKernelWrapper
{
    private const double defaultFluidisationGradient = 0.3;
    private const double defaultMaxReturnValue = 90.0;

    /// <summary>
    /// Create the kernel input.
    /// </summary>
    /// <param name="damKernelInput">The dam kernel input.</param>
    /// <param name="iterationIndex">The number of the current iteration.</param>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <returns>
    /// Result of the prepare
    /// </returns>
    public PrepareResult Prepare(DamKernelInput damKernelInput, int iterationIndex, out IKernelDataInput kernelDataInput, out IKernelDataOutput kernelDataOutput)
    {
        var damPipingBlighOutput = new DamPipingBlighOutput
        {
            CalculationResult = CalculationResult.NoRun,
            FoSp = defaultMaxReturnValue
        };
        kernelDataOutput = damPipingBlighOutput;
        if (damKernelInput.SubSoilScenario.SegmentFailureMechanismType.Value.In(SegmentFailureMechanismType.Piping, SegmentFailureMechanismType.All))
        {
            var damPipingBlighInput = new DamPipingBlighInput();

            SoilProfile1D soilProfile1D = damKernelInput.SubSoilScenario.SoilProfile1D;
            Location location = damKernelInput.Location;
            double waterLevel = damKernelInput.RiverLevelHigh;
            PlLines plLines = PlLinesHelper.CreatePlLinesForPiping(damKernelInput.TimeStepDateTime, location, soilProfile1D, waterLevel);
            if (EvaluateUpliftSituation(damKernelInput, out kernelDataInput, plLines, damPipingBlighInput, waterLevel, damPipingBlighOutput))
            {
                return PrepareResult.Successful;
            }
        }

        kernelDataInput = null;
        return PrepareResult.NotRelevant;
    }

    /// <summary>
    /// Validates the kernel data input.
    /// </summary>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <param name="messages">The messages.</param>
    /// <returns>
    /// Number of errors that prevent a calculation
    /// </returns>
    public int Validate(IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, out List<LogMessage> messages)
    {
        var damPipingBlighOutput = (DamPipingBlighOutput) kernelDataOutput;
        PipingCalculatorBligh calculatorBligh = CreatePipingCalculatorBligh(kernelDataInput);
        List<string> kernelMessages = calculatorBligh.Validate();
        messages = new List<LogMessage>();
        foreach (string stringMessage in kernelMessages)
        {
            messages.Add(new LogMessage
            {
                Message = stringMessage,
                MessageType = LogMessageType.Error
            });
        }

        if (messages.Count > 0)
        {
            damPipingBlighOutput.CalculationResult = CalculationResult.InvalidInputData;
        }

        return messages.Count;
    }

    /// <summary>
    /// Executes the kernel.
    /// </summary>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <param name="messages">The messages.</param>
    /// <exception cref="NoNullAllowedException">No input object defined for Bligh</exception>
    public void Execute(IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, out List<LogMessage> messages)
    {
        var damPipingBlighInput = kernelDataInput as DamPipingBlighInput;
        var damPipingBlighOutput = (DamPipingBlighOutput) kernelDataOutput;
        ThrowWhenKernelInputNull(damPipingBlighInput);
        ThrowWhenKernelOutputNull(damPipingBlighOutput);
        PerformSingleCalculationBligh(out messages, damPipingBlighOutput, damPipingBlighInput);
    }

    /// <summary>
    /// Fills the design results from the kernel output.
    /// </summary>
    /// <param name="damKernelInput">The dam kernel input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <param name="designScenario">The design scenario.</param>
    /// <param name="resultMessage">The result message.</param>
    /// <param name="designResults">The design results.</param>
    /// <exception cref="NoNullAllowedException">No output object defined for Bligh</exception>
    public void PostProcess(DamKernelInput damKernelInput, IKernelDataOutput kernelDataOutput,
                            DesignScenario designScenario, string resultMessage,
                            out List<DesignResult> designResults)
    {
        var damPipingBlighOutput = kernelDataOutput as DamPipingBlighOutput;
        ThrowWhenDamKernelInputNull(damKernelInput);
        ThrowWhenKernelOutputNull(damPipingBlighOutput);

        designResults = new List<DesignResult>();
        var designResult = new DesignResult(damKernelInput.DamFailureMechanismeCalculationSpecification,
                                            designScenario, damKernelInput.SubSoilScenario.SoilProfile1D, null)
        {
            CalculationResult = damPipingBlighOutput.CalculationResult
        };
        var pipingDesignResults = new PipingDesignResults(PipingModelType.Bligh);
        designResult.PipingDesignResults = pipingDesignResults;
        pipingDesignResults.ResultMessage = resultMessage;
        pipingDesignResults.BlighFactor = damPipingBlighOutput.FoSp;
        pipingDesignResults.BlighHcritical = damPipingBlighOutput.Hc;
        pipingDesignResults.RedesignedSurfaceLine = damKernelInput.Location.SurfaceLine;
        pipingDesignResults.UpliftSituation = damPipingBlighOutput.UpliftSituation;
        pipingDesignResults.LocalExitPointX = damPipingBlighOutput.ExitPointX;
        pipingDesignResults.UpliftFactor = damPipingBlighOutput.UpliftFactor;
        designResults.Add(designResult);
    }

    /// <summary>
    /// Calculates the design at point.
    /// </summary>
    /// <param name="damKernelInput">The dam kernel input.</param>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <param name="point">The point.</param>
    /// <param name="messages">The messages.</param>
    /// <returns></returns>
    public ShoulderDesign CalculateDesignAtPoint(DamKernelInput damKernelInput, IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, GeometryPoint point, out List<LogMessage> messages)
    {
        messages = new List<LogMessage>();
        var damPipingBlighInput = kernelDataInput as DamPipingBlighInput;
        var damPipingBlighOutput = (DamPipingBlighOutput) kernelDataOutput;
        ThrowWhenDamKernelInputNull(damKernelInput);
        ThrowWhenKernelOutputNull(damPipingBlighOutput);
        Location location = damKernelInput.Location;
        SoilProfile1D soilProfile = damKernelInput.SubSoilScenario.SoilProfile1D;
        SurfaceLine2 surfaceLine = damKernelInput.Location.SurfaceLine;

        PlLines plLines;
        UpliftLocationAndResult upliftLocationAndResult;
        DamPipingHelper.DeterminePlLinesAndUpliftLocation(damKernelInput, point, out plLines, out upliftLocationAndResult);

        double requiredFoS = location.ModelFactors.RequiredSafetyFactorPiping;
        double upliftCriterion = location.UpliftCriterionPiping;
        // if there is no uplift, then there is no piping so return null
        if (upliftLocationAndResult != null)
        {
            double xEntry = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X;
            double xExit = upliftLocationAndResult.X;
            damPipingBlighInput.SeepageLength = xExit - xEntry;
            double topLevelAquifer = soilProfile.GetLayerWithName(upliftLocationAndResult.LayerWhereUpliftOccuresId).TopLevel;

            // The following 2 parameters are dependent on the position of the point and have to be recalculated for the current point
            double dCoverLayer = DamPipingHelper.DetermineHeightCoverLayer(topLevelAquifer, point.Z); // point.Z is surfacelevel
            damPipingBlighInput.DTotal = dCoverLayer;
            double referenceLevel = Math.Max(location.CurrentScenario.PolderLevel, point.Z); // point.Z is surfacelevel
            damPipingBlighInput.HExit = referenceLevel;

            // Calculate the piping safety factor using the level of the given point
            PerformSingleCalculationBligh(out messages, damPipingBlighOutput, damPipingBlighInput);

            // If too low, then determine required height and length (from uplift)
            if (damPipingBlighOutput.FoSp < requiredFoS)
            {
                // Finally, determine the required shoulderheight
                double currentShoulderHeight = upliftLocationAndResult.Z -
                                               surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
                var shoulderDesign = new ShoulderDesign(
                    upliftLocationAndResult.X - surfaceLine.GetDikeToeInward().X,
                    currentShoulderHeight + ShoulderDesignHelper.CalculateExtraShoulderHeight(soilProfile, plLines, upliftLocationAndResult, upliftCriterion));
                return shoulderDesign;
            }
        }

        return null;
    }

    /// <summary>
    /// Evaluates the design (current factor greater than desired factor)
    /// </summary>
    /// <param name="damKernelInput">The dam kernel input.</param>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <param name="kernelDataOutput">The kernel data output.</param>
    /// <param name="designAdvise">The design advise.</param>
    /// <param name="evaluationMessage">The evaluation message.</param>
    /// <returns>
    /// if the design was succesful
    /// </returns>
    /// <exception cref="System.NotImplementedException"></exception>
    public bool EvaluateDesign(DamKernelInput damKernelInput, IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput,
                               out DesignAdvise designAdvise, out string evaluationMessage)
    {
        var damPipingBlighInput = kernelDataInput as DamPipingBlighInput;
        var damPipingBlighOutput = (DamPipingBlighOutput) kernelDataOutput;
        ThrowWhenKernelInputNull(damPipingBlighInput);
        ThrowWhenDamKernelInputNull(damKernelInput);
        ThrowWhenKernelOutputNull(damPipingBlighOutput);
        double fosRequired = damKernelInput.Location.ModelFactors.RequiredSafetyFactorPiping;
        double fosAchieved = damPipingBlighOutput.FoSp;
        evaluationMessage = String.Format(Resources.FactorAchievedVsFactorRequired, fosAchieved, fosRequired);
        designAdvise = DesignAdvise.None;
        return (fosAchieved >= fosRequired);
    }

    public void PrepareDesign(IKernelDataInput kernelDataInput, IKernelDataOutput kernelDataOutput, DamKernelInput damKernelInput,
                              int iterationIndex, out EmbankmentDesignParameters embankmentDesignParameters)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// Gets the design strategy
    /// </summary>
    /// <param name="damKernelInput"></param>
    /// <returns></returns>
    public DesignStrategy GetDesignStrategy(DamKernelInput damKernelInput)
    {
        return DesignStrategy.ShoulderPerPoint;
    }

    private bool EvaluateUpliftSituation(DamKernelInput damKernelInput, out IKernelDataInput kernelDataInput, PlLines plLines,
                                         DamPipingBlighInput damPipingBlighInput, double waterLevel,
                                         DamPipingBlighOutput damPipingBlighOutput)
    {
        const double upliftCriterionTolerance = 0.000000001;
        SoilProfile1D soilProfile1D = damKernelInput.SubSoilScenario.SoilProfile1D;
        SurfaceLine2 surfaceLine = damKernelInput.Location.SurfaceLine;
        Location location = damKernelInput.Location;
        var upliftSituation = new UpliftSituation();
        var upliftLocationDeterminator = new UpliftLocationDeterminator
        {
            PlLines = plLines,
            SoilProfile = soilProfile1D,
            SurfaceLine = surfaceLine,
            DikeEmbankmentMaterial = location.GetDikeEmbankmentSoil(),
            XSoilGeometry2DOrigin = location.XSoilGeometry2DOrigin
        };
        // The tolerance is built in because after design it could be that the value that is designed to, is not reached by this margin
        double upliftCriterion = location.UpliftCriterionPiping - upliftCriterionTolerance;
        UpliftLocationAndResult upliftLocationAndResult = upliftLocationDeterminator.GetLocationAndResult(upliftCriterion);
        upliftSituation.IsUplift = (upliftLocationAndResult != null);
        double xEntry = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).X;
        if (upliftLocationAndResult != null)
        {
            double xExit = upliftLocationAndResult.X;
            double surfaceLevel = surfaceLine.Geometry.GetZatX(upliftLocationAndResult.X);
            SoilLayer1D heaveLayer = soilProfile1D.GetLayerWithName(upliftLocationAndResult.LayerWhereUpliftOccuresId);
            double d70 = Physics.FactorMeterToMicroMeter * heaveLayer.Soil.DiameterD70;
            double topLevelAquifer = soilProfile1D.GetLayerWithName(upliftLocationAndResult.LayerWhereUpliftOccuresId).TopLevel;
            double dCoverLayer = DamPipingHelper.DetermineHeightCoverLayer(topLevelAquifer, surfaceLevel);
            double? upliftFactor = upliftLocationAndResult.UpliftFactor;
            double seepageLength = xExit - xEntry;
            damPipingBlighInput.HRiver = waterLevel;
            // Reference level is highest value of surfaceLevel or PolderLevel
            // Uit TR Zandmeevoerende wellen (1999): "Het verval dH is gelijk aan het verschil tussen buitenwaterstand (het ontwerppeil(OP)) 
            // bij zeedijken en de maatgevende hoogwaterstand (MHW bij rivierdijken) en de waterstand binnendijks ter plaatse van het uittredepunt, 
            // rekening houdend met zeespiegelrijzing etc.(zie paragraaf 3.7.2). In dien ter plaatse van het uittreepunt of de opbarstlocatie 
            // geen vrije waterstand heerst kan gerekend worden met het maaiveldniveau, rekening houdend met eventuele maaiveld daling (zie paragraaf 3.7.2)."
            double referenceLevel = Math.Max(location.CurrentScenario.PolderLevel, surfaceLevel);
            kernelDataInput = new DamPipingBlighInput
            {
                HRiver = waterLevel,
                HExit = referenceLevel,
                Rc = defaultFluidisationGradient,
                DTotal = dCoverLayer,
                SeepageLength = seepageLength,
                D70 = d70
            };
            damPipingBlighOutput.ExitPointX = xExit;
            damPipingBlighOutput.UpliftFactor = upliftFactor;
            damPipingBlighOutput.UpliftSituation = upliftSituation;
            return true;
        }

        kernelDataInput = new DamPipingBlighInput();
        return false;
    }

    private void PerformSingleCalculationBligh(out List<LogMessage> messages, DamPipingBlighOutput damPipingBlighOutput, DamPipingBlighInput damPipingBlighInput)
    {
        damPipingBlighOutput.CalculationResult = CalculationResult.NoRun;
        damPipingBlighOutput.FoSp = defaultMaxReturnValue;
        messages = new List<LogMessage>();
        try
        {
            if (damPipingBlighOutput.UpliftSituation.IsUplift)
            {
                PipingCalculatorBligh calculatorBligh = CreatePipingCalculatorBligh(damPipingBlighInput);
                calculatorBligh.Calculate();
                damPipingBlighOutput.FoSp = calculatorBligh.FoSp;
                damPipingBlighOutput.Hc = calculatorBligh.Hc;
                damPipingBlighOutput.CalculationResult = CalculationResult.Succeeded;
            }
        }
        catch (Exception e)
        {
            damPipingBlighOutput.CalculationResult = CalculationResult.UnexpectedError;
            messages.Add(new LogMessage(LogMessageType.Error, null, e.Message));
        }
    }

    /// <summary>
    /// Creates the piping calculator bligh based on kernel input.
    /// </summary>
    /// <param name="kernelDataInput">The kernel data input.</param>
    /// <returns></returns>
    /// <exception cref="NoNullAllowedException">No input object defined for Bligh</exception>
    private PipingCalculatorBligh CreatePipingCalculatorBligh(IKernelDataInput kernelDataInput)
    {
        var damPipingBlighInput = kernelDataInput as DamPipingBlighInput;
        ThrowWhenKernelInputNull(damPipingBlighInput);
        var calculator = new PipingCalculatorBligh
        {
            HRiver = damPipingBlighInput.HRiver,
            HExit = damPipingBlighInput.HExit,
            Rc = damPipingBlighInput.Rc,
            DTotal = damPipingBlighInput.DTotal,
            SeepageLength = damPipingBlighInput.SeepageLength,
            D70 = damPipingBlighInput.D70
        };
        return calculator;
    }

    private void ThrowWhenKernelInputNull(DamPipingBlighInput damPipingBlighInput)
    {
        if (damPipingBlighInput == null)
        {
            throw new NoNullAllowedException(Resources.DamPipingBlighKernelWrapper_NoInputObjectDefinedForBligh);
        }
    }

    private void ThrowWhenKernelOutputNull(DamPipingBlighOutput damPipingBlighOutput)
    {
        if (damPipingBlighOutput == null)
        {
            throw new NoNullAllowedException(Resources.DamPipingBlighKernelWrapper_NoOutputObjectDefinedForBligh);
        }
    }

    private void ThrowWhenDamKernelInputNull(DamKernelInput damKernelInput)
    {
        if (damKernelInput == null)
        {
            throw new NoNullAllowedException(Resources.DamPipingBlighKernelWrapper_NoDamInputObjectDefinedForBligh);
        }
    }
}