// 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.Collections.Specialized;
using System.ComponentModel;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Language;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.Design;

/// <summary>
/// Calculation scenario class
/// </summary>
public class DesignScenario
{
    private Dictionary<Object, SurfaceLine2> redesignedSurfaceLines;
    private Dictionary<Object, string> resultMessages;

    /// <summary>
    /// Constructor
    /// </summary>
    public DesignScenario()
    {
        ClearResults();
        ClearErrors();
    }

    public CalculationResult CalculationResult { get; set; } = CalculationResult.NoRun;

    /// <summary>
    /// Gets or sets the location scenario identifier.
    /// </summary>
    /// <value>
    /// The location scenario identifier.
    /// </value>
    public string LocationScenarioID { get; set; }

    /// <summary>
    /// The name of the location to which the scenario belongs 
    /// </summary>
    public string LocationName { get; set; }

    /// <summary>
    /// Gets or sets the polder level.
    /// </summary>
    /// <value>
    /// The polder level.
    /// </value>
    public double PolderLevel { get; set; }

    [Browsable(false)] public StringCollection Errors { get; private set; }

    /// <summary>
    /// Gets or sets the river level.
    /// </summary>
    /// <value>
    /// The river level.
    /// </value>
    [Description("River level")]
    public double RiverLevel { get; set; }

    /// <summary>
    /// Gets or sets the river level low.
    /// </summary>
    /// <value>
    /// The river level low.
    /// </value>
    [Description("River level low")]
    public double? RiverLevelLow { get; set; }

    /// <summary>
    /// Gets or sets the height of the dike table.
    /// </summary>
    /// <value>
    /// The height of the dike table.
    /// </value>
    [Description("Dike table height")]
    public double? DikeTableHeight { get; set; }

    /// <summary>
    /// Gets or sets the required safety factor stability inner slope.
    /// </summary>
    /// <value>
    /// The required safety factor stability inner slope.
    /// </value>
    [Description("Required safety factor stability inner slope")]
    public double RequiredSafetyFactorStabilityInnerSlope { get; set; }
    
    /// <summary>
    /// Gets or sets the required safety factor stability outer slope.
    /// </summary>
    /// <value>
    /// The required safety factor stability outer slope.
    /// </value>
    [Description("Required safety factor stability outer slope")]
    public double RequiredSafetyFactorStabilityOuterSlope { get; set; }
    

    /// <summary>
    /// Gets or sets the required safety factor piping.
    /// </summary>
    /// <value>
    /// The required safety factor piping.
    /// </value>
    [Description("Required safety factor piping")]
    public double RequiredSafetyFactorPiping {get; set; }
    

    /// <summary>
    /// Gets or sets the uplift criterion piping.
    /// </summary>
    /// <value>
    /// The uplift criterion piping.
    /// </value>
    [Description("Uplift criterion piping")]
    public double UpliftCriterionPiping {get; set; }
    
    /// <summary>
    /// Gets or sets the uplift criterion stability.
    /// </summary>
    /// <value>
    /// The uplift criterion stability.
    /// </value>
    [Description("Uplift criterion stability")]
    public double UpliftCriterionStability { get; set; }
    
    public double PlLineOffsetBelowDikeTopAtRiver { get; set; } = 0.5;

    /// <summary>
    /// Gets or sets the pl line offset below dike top at polder.
    /// </summary>
    /// <value>
    /// The pl line offset below dike top at polder.
    /// </value>
    public double PlLineOffsetBelowDikeTopAtPolder { get; set; } = 1.5;

    /// <summary>
    /// Gets or sets the pl line offset below shoulder base inside.
    /// </summary>
    /// <value>
    /// The pl line offset below shoulder base inside.
    /// </value>
    public double PlLineOffsetBelowShoulderBaseInside { get; set; } = 0.1;

    /// <summary>
    /// Gets or sets the pl line offset below dike toe at polder.
    /// </summary>
    /// <value>
    /// The pl line offset below dike toe at polder.
    /// </value>
    public double PlLineOffsetBelowDikeToeAtPolder { get; set; } = 0.1;

    /// <summary>
    /// Gets or sets the use pl line offset below dike crest middle.
    /// </summary>
    /// <value>
    /// The use pl line offset below dike crest middle.
    /// </value>
    public bool? UsePlLineOffsetBelowDikeCrestMiddle { get; set; }

    /// <summary>
    /// Gets or sets the pl line offset below dike crest middle.
    /// </summary>
    /// <value>
    /// The pl line offset below dike crest middle.
    /// </value>
    public double? PlLineOffsetBelowDikeCrestMiddle { get; set; }

    /// <summary>
    /// Gets or sets the use pl line offset factor below shoulder crest.
    /// </summary>
    /// <value>
    /// The use pl line offset factor below shoulder crest.
    /// </value>
    public bool? UsePlLineOffsetFactorBelowShoulderCrest { get; set; }

    /// <summary>
    /// Gets or sets the pl line offset factor below shoulder crest.
    /// </summary>
    /// <value>
    /// The pl line offset factor below shoulder crest.
    /// </value>
    public double? PlLineOffsetFactorBelowShoulderCrest { get; set; }

    /// <summary>
    /// Gets or sets the head PL2.
    /// </summary>
    /// <value>
    /// The head PL2.
    /// </value>
    public virtual double? HeadPl2 { get; set; }

    /// <summary>
    /// Gets or sets the head PL3.
    /// </summary>
    /// <value>
    /// The head PL3.
    /// </value>
    public double? HeadPl3 { get; set; }

    /// <summary>
    /// Gets or sets the head PL4.
    /// </summary>
    /// <value>
    /// The head PL4.
    /// </value>
    public double? HeadPl4 { get; set; }

    /// <summary>
    /// Clone the input part of the current scenario to a new instance 
    /// </summary>
    /// <param name="locationName"></param>
    /// <returns></returns>
    public DesignScenario CloneInput()
    {
        // Synchronize scenario data (Note: do not attempt to synchronize the ModelFactors as these are set by the direct
        // properties in the scenario such as the Required Safeties. ModelFactors is just a place holder. 
        var newCurrentScenario = new DesignScenario();
        newCurrentScenario.LocationName = LocationName;
        newCurrentScenario.LocationScenarioID = LocationScenarioID;
        newCurrentScenario.PolderLevel = PolderLevel;
        newCurrentScenario.RiverLevel = RiverLevel;
        newCurrentScenario.RiverLevelLow = RiverLevelLow;
        newCurrentScenario.DikeTableHeight = DikeTableHeight;
        newCurrentScenario.RequiredSafetyFactorStabilityInnerSlope = RequiredSafetyFactorStabilityInnerSlope;
        newCurrentScenario.RequiredSafetyFactorStabilityOuterSlope = RequiredSafetyFactorStabilityOuterSlope;
        newCurrentScenario.RequiredSafetyFactorPiping = RequiredSafetyFactorPiping;
        newCurrentScenario.UpliftCriterionPiping = UpliftCriterionPiping;
        newCurrentScenario.UpliftCriterionStability = UpliftCriterionStability;
        newCurrentScenario.PlLineOffsetBelowDikeTopAtPolder = PlLineOffsetBelowDikeTopAtPolder;
        newCurrentScenario.PlLineOffsetBelowDikeTopAtRiver = PlLineOffsetBelowDikeTopAtRiver;
        newCurrentScenario.PlLineOffsetBelowShoulderBaseInside = PlLineOffsetBelowShoulderBaseInside;
        newCurrentScenario.PlLineOffsetBelowDikeToeAtPolder = PlLineOffsetBelowDikeToeAtPolder;
        newCurrentScenario.UsePlLineOffsetBelowDikeCrestMiddle = UsePlLineOffsetBelowDikeCrestMiddle;
        newCurrentScenario.PlLineOffsetBelowDikeCrestMiddle = PlLineOffsetBelowDikeCrestMiddle;
        newCurrentScenario.UsePlLineOffsetFactorBelowShoulderCrest = UsePlLineOffsetFactorBelowShoulderCrest;
        newCurrentScenario.PlLineOffsetFactorBelowShoulderCrest = PlLineOffsetFactorBelowShoulderCrest;
        newCurrentScenario.HeadPl2 = HeadPl2;
        newCurrentScenario.HeadPl3 = HeadPl3;
        newCurrentScenario.HeadPl4 = HeadPl4;
        return newCurrentScenario;
    }

    /// <summary>
    /// Clears the errors.
    /// </summary>
    public void ClearErrors()
    {
        Errors = new StringCollection();
    }

    /// <summary>
    /// Clears the results
    /// </summary>
    public void ClearResults()
    {
        CalculationResult = CalculationResult.NoRun;
        resultMessages = new Dictionary<Object, string>();
        redesignedSurfaceLines = new Dictionary<Object, SurfaceLine2>();
    }

    /// <summary>
    /// Determines whether [is pl line offset factor below shoulder crest valid].
    /// </summary>
    /// <returns></returns>
    [Validate]
    public ValidationResult[] IsPlLineOffsetFactorBelowShoulderCrestValid()
    {
        if (UsePlLineOffsetFactorBelowShoulderCrest.HasValue && UsePlLineOffsetFactorBelowShoulderCrest.Value &&
            PlLineOffsetFactorBelowShoulderCrest.HasValue)
        {
            if (PlLineOffsetFactorBelowShoulderCrest.Value < DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMinValue)
            {
                return new[]
                {
                    new ValidationResult(ValidationResultType.Error,
                                         LocalizationManager.GetTranslatedText(this, "PlLineOffsetFactorBelowShoulderCrestTooSmall"),
                                         this)
                };
            }

            if (PlLineOffsetFactorBelowShoulderCrest.Value > DamGlobalConstants.PlLineOffsetFactorBelowShoulderCrestMaxValue)
            {
                return new[]
                {
                    new ValidationResult(ValidationResultType.Error,
                                         LocalizationManager.GetTranslatedText(this, "PlLineOffsetFactorBelowShoulderCrestTooLarge"),
                                         this)
                };
            }
        }

        return new ValidationResult[0];
    }

    /// <summary>
    /// Get Result Message
    /// </summary>
    /// <param name="soilProfile"></param>
    /// <param name="soilProfile2D"></param>
    /// <returns></returns>
    public string GetResultMessage(SoilProfile1D soilProfile, SoilProfile2D soilProfile2D)
    {
        Object objectAsKey = GetObjectAsKey(soilProfile, soilProfile2D);
        return GetResultMessage(objectAsKey);
    }

    /// <summary>
    /// Set Result Message
    /// </summary>
    /// <param name="soilProfile"></param>
    /// <param name="soilProfile2D"></param>
    /// <param name="resultMessage"></param>
    public void SetResultMessage(SoilProfile1D soilProfile, SoilProfile2D soilProfile2D, string resultMessage)
    {
        Object objectAsKey = GetObjectAsKey(soilProfile, soilProfile2D);
        SetResultMessage(objectAsKey, resultMessage);
    }

    /// <summary>
    /// Set Redesigned surfaceline
    /// </summary>
    /// <param name="soilProfile1D"></param>
    /// <param name="soilProfile2D"></param>
    /// <param name="surfaceLine"></param>
    /// <exception cref="ArgumentNullException">soilProfile1D and soilProfile2D can not both be null</exception>
    public void SetRedesignedSurfaceLine(SoilProfile1D soilProfile1D, SoilProfile2D soilProfile2D, SurfaceLine2 surfaceLine)
    {
        if ((soilProfile1D == null) && (soilProfile2D == null))
        {
            throw new ArgumentException("Both soilProfile1D and soilProfile2D are null.");
        }
        object objectAsKey = GetObjectAsKey(soilProfile1D, soilProfile2D);
        SetRedesignedSurfaceLine(objectAsKey, surfaceLine);
    }

    /// <summary>
    /// Get Most recent surfaceline
    /// </summary>
    /// <param name="soilProfile"></param>
    /// <param name="soilProfile2D"></param>
    /// <returns></returns>
    public SurfaceLine2 GetMostRecentSurfaceLine(SoilProfile soilProfile, SoilProfile2D soilProfile2D)
    {
        var profile1D = soilProfile as SoilProfile1D;
        Object objectAsKey = GetObjectAsKey(profile1D, soilProfile2D);
        return GetMostRecentSurfaceLine(objectAsKey);
    }

    /// <summary>
    /// Implementation of ToString
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return $"Location={LocationName}, ID={LocationScenarioID} RiverLevel={RiverLevel} " +
               $"RiverLevelLow={(RiverLevelLow.HasValue ? RiverLevelLow.ToString() : "?")} " +
               $"DikeTableHeight={(DikeTableHeight.HasValue ? DikeTableHeight.ToString() : "?")} " +
               $"SafetyFactorStabilityInnerSlope={RequiredSafetyFactorStabilityInnerSlope} " +
               $"RequiredSafetyFactorStabilityOuterSlope={RequiredSafetyFactorStabilityOuterSlope} " +
               $"PlLineOffsetBelowDikeTopAtRiver={PlLineOffsetBelowDikeTopAtRiver} " +
               $"PlLineOffsetBelowDikeToeAtPolder={PlLineOffsetBelowDikeToeAtPolder} " +
               $"PlLineOffsetBelowDikeTopAtPolder={PlLineOffsetBelowDikeTopAtPolder} " +
               $"PlLineOffsetBelowShoulderBaseInside={PlLineOffsetBelowShoulderBaseInside} " +
               $"UsePlLineOffsetBelowDikeCrestMiddle {(UsePlLineOffsetBelowDikeCrestMiddle.HasValue ? UsePlLineOffsetBelowDikeCrestMiddle.ToString() : "?")} " +
               $"PlLineOffsetBelowDikeCrestMiddle {(PlLineOffsetBelowDikeCrestMiddle.HasValue ? PlLineOffsetBelowDikeCrestMiddle.ToString() : "?")} " +
               $"UsePlLineOffsetFactorBelowShoulderCrest {(UsePlLineOffsetFactorBelowShoulderCrest.HasValue ? UsePlLineOffsetFactorBelowShoulderCrest.ToString() : "?")} " +
               $"PlLineOffsetFactorBelowShoulderCrest {(PlLineOffsetFactorBelowShoulderCrest.HasValue ? PlLineOffsetFactorBelowShoulderCrest.ToString() : "?")} " +
               $"HeadPl2={(HeadPl2.HasValue ? HeadPl2.ToString() : "?")} " +
               $"HeadPl3={(HeadPl3.HasValue ? HeadPl3.ToString() : "?")} " +
               $"HeadPl4={(HeadPl4.HasValue ? HeadPl4.ToString() : "?")} " + $"PolderLevel={PolderLevel} ";
    }

    /// <summary>
    /// Get Result Message
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <returns></returns>
    private string GetResultMessage(Object objectAsKey)
    {
        if (objectAsKey != null)
        {
            return resultMessages.ContainsKey(objectAsKey) ? resultMessages[objectAsKey] : null;
        }

        return null;
    }

    /// <summary>
    /// Set Result Message
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <param name="resultMessage"></param>
    private void SetResultMessage(Object objectAsKey, string resultMessage)
    {
        resultMessages[objectAsKey] = resultMessage;
    }

    /// <summary>
    /// Set Redesigned surfaceline
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <param name="surfaceLine"></param>
    private void SetRedesignedSurfaceLine(Object objectAsKey, SurfaceLine2 surfaceLine)
    {
        redesignedSurfaceLines[objectAsKey] = surfaceLine;
    }

    /// <summary>
    /// Get Most recent surfaceline
    /// </summary>
    /// <param name="objectAsKey"></param>
    /// <returns></returns>
    private SurfaceLine2 GetMostRecentSurfaceLine(Object objectAsKey)
    {
        if (objectAsKey != null)
        {
            //return redesignedSurfaceLines.ContainsKey(objectAsKey) ? redesignedSurfaceLines[objectAsKey] ?? Location.SurfaceLine : Location.SurfaceLine;
            // For debugging: following code is the same as above, but better debuggable
            SurfaceLine2 surfaceLine = null;
            if (redesignedSurfaceLines.ContainsKey(objectAsKey))
            {
                SurfaceLine2 s = redesignedSurfaceLines[objectAsKey];
                if (s != null)
                {
                    surfaceLine = s;
                }
            }

            return surfaceLine;
        }

        return null;
    }

    /// <summary>
    /// Determine object key based on either 1d-soilprofile or 2d-geometry
    /// 
    /// </summary>
    /// <param name="soilProfile"></param>
    /// <param name="soilProfile2D"></param>
    /// <returns></returns>
    private Object GetObjectAsKey(SoilProfile1D soilProfile, SoilProfile2D soilProfile2D)
    {
        if (soilProfile != null)
        {
            return soilProfile;
        }

        return soilProfile2D;
    }
}