// Copyright (C) Stichting Deltares 2019. 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 CalculationResult calculationResult = CalculationResult.NoRun;
        private Location location;
        
        private Dictionary<Object, SurfaceLine2> redesignedSurfaceLines;
        private Dictionary<Object, string> resultMessages;

        private string locationScenarioId;
        private double riverLevel;
        private double? riverLevelLow;
        private double? dikeTableHeight;
        private double? plLineOffsetBelowDikeTopAtRiver;
        private double? plLineOffsetBelowDikeTopAtPolder;
        private double? plLineOffsetBelowShoulderBaseInside;
        private double? plLineOffsetBelowDikeToeAtPolder;
        private bool? usePlLineOffsetBelowDikeCrestMiddle;
        private double? plLineOffsetBelowDikeCrestMiddle;
        private bool? usePlLineOffsetFactorBelowShoulderCrest;
        private double? plLineOffsetFactorBelowShoulderCrest;
        private double? headPl3;
        private double? headPl4;
        private double? waterHeightDecimeringsHoogte;
        private double? maxWaterLevel;

        public CalculationResult CalculationResult
        {
            get { return calculationResult; }
            set { calculationResult = value; }
        }

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

        /// <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>
        /// Gets or sets the location scenario identifier.
        /// </summary>
        /// <value>
        /// The location scenario identifier.
        /// </value>
        public string LocationScenarioID
        {
            get
            {
                return locationScenarioId;
            }
            set
            {
                locationScenarioId = value;
            }
        }

        [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
            {
                return riverLevel;
            }
            set
            {
                riverLevel = value;
            }
        }

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

        /// <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
            {
                return dikeTableHeight;
            }
            set
            {
                dikeTableHeight = value;
            }
        }

        /// <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 { return ModelFactors.RequiredSafetyFactorStabilityInnerSlope; }
            set
            {
                ModelFactors.RequiredSafetyFactorStabilityInnerSlope = value;
            }
        }

        /// <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 { return ModelFactors.RequiredSafetyFactorStabilityOuterSlope; }
            set
            {
                ModelFactors.RequiredSafetyFactorStabilityOuterSlope = value;
            }
        }

        /// <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 { return ModelFactors.RequiredSafetyFactorPiping; }
            set
            {
                ModelFactors.RequiredSafetyFactorPiping = value;
            }
        }

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

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

        public double? PlLineOffsetBelowDikeTopAtRiver
        {
            get
            {
                return plLineOffsetBelowDikeTopAtRiver;
            }
            set
            {
                plLineOffsetBelowDikeTopAtRiver = value;
            }
        }

        /// <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
            {
                return plLineOffsetBelowDikeTopAtPolder;
            }
            set
            {
                plLineOffsetBelowDikeTopAtPolder = value;
            }
        }

        /// <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
            {
                return plLineOffsetBelowShoulderBaseInside;
            }
            set
            {
                plLineOffsetBelowShoulderBaseInside = value;
            }
        }

        /// <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
            {
                return plLineOffsetBelowDikeToeAtPolder;
            }
            set
            {
                plLineOffsetBelowDikeToeAtPolder = value;
            }
        }

        /// <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
            {
                return usePlLineOffsetBelowDikeCrestMiddle;
            }
            set
            {
                usePlLineOffsetBelowDikeCrestMiddle = value;
            }
        }

        /// <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 { return plLineOffsetBelowDikeCrestMiddle; }
            set
            {
                plLineOffsetBelowDikeCrestMiddle = value;
            }
        }

        /// <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
            {
                return usePlLineOffsetFactorBelowShoulderCrest;
            }
            set
            {
                usePlLineOffsetFactorBelowShoulderCrest = value;
            }
        }

        /// <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 { return plLineOffsetFactorBelowShoulderCrest; }
            set
            {
                plLineOffsetFactorBelowShoulderCrest = value;
            }
        }

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

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

        /// <summary>
        /// Gets or sets the water height decimerings hoogte.
        /// </summary>
        /// <value>
        /// The water height decimerings hoogte.
        /// </value>
        public double? WaterHeightDecimeringsHoogte
        {
            get
            {
                return waterHeightDecimeringsHoogte;
            }
            set
            {
                waterHeightDecimeringsHoogte = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum water level.
        /// </summary>
        /// <value>
        /// The maximum water level.
        /// </value>
        public double? MaxWaterLevel
        {
            get
            {
                return maxWaterLevel;
            }
            set
            {
                maxWaterLevel = value;
            }
        }

        /// <summary>
        /// Gets or sets the model factors.
        /// </summary>
        /// <value>
        /// The model factors.
        /// </value>
        public ModelFactors ModelFactors { get; set; }

        /// <remarks>Aggregation relationship.</remarks>
        public Location Location
        {
            get { return location; }
            set { location = value; }
        }

        /// <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="objectAsKey"></param>
        /// <returns></returns>
        private string GetResultMessage(Object objectAsKey)
        {
            if (objectAsKey != null)
            {
                return resultMessages.ContainsKey(objectAsKey) ? resultMessages[objectAsKey] : null;
            }
            return null;
        }

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

        /// <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 Result Message
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="resultMessage"></param>
        public void SetResultMessage(SoilProfile1D soilProfile, string soilGeometry2DName, string resultMessage)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetResultMessage(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>
        /// Set Redesigned surfaceline
        /// </summary>
        /// <param name="soilProfile"></param>
        /// <param name="soilGeometry2DName"></param>
        /// <param name="surfaceLine"></param>
        public void SetRedesignedSurfaceLine(SoilProfile1D soilProfile, string soilGeometry2DName, SurfaceLine2 surfaceLine)
        {
            Object objectAsKey = GetObjectAsKey(soilProfile, soilGeometry2DName);
            SetRedesignedSurfaceLine(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 = Location.SurfaceLine;
                // if (redesignedSurfaceLines.ContainsKey(objectAsKey))
                // {
                //     var s = redesignedSurfaceLines[objectAsKey];
                //     if (s != null)
                //     {
                //         surfaceline = s;
                //     }
                // }
                // return surfaceline;
            }
            return null;
        }

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

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

        /// <summary>
        /// Implementation of ToString
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return String.Format("Location={0}, ID={1} RiverLevel={2} " +
                                 "RiverLevelLow={3} " +
                                 "DikeTableHeight={4} " +
                                 "SafetyFactorStabilityInnerSlope={5} " +
                                 "RequiredSafetyFactorStabilityOuterSlope={6} " +
                                 "WaterHeightDecimeringsHoogte= {7} " +
                                 "MaxWaterheight={8} " +
                                 "PlLineOffsetBelowDikeTopAtRiver={9} " +
                                 "PlLineOffsetBelowDikeToeAtPolder={10} " +
                                 "PlLineOffsetBelowDikeTopAtPolder={11} " +
                                 "PlLineOffsetBelowShoulderBaseInside={12} " +
                                 "UsePlLineOffsetBelowDikeCrestMiddle {13} " +
                                 "PlLineOffsetBelowDikeCrestMiddle {14} " +
                                 "UsePlLineOffsetFactorBelowShoulderCrest {15} " +
                                 "PlLineOffsetFactorBelowShoulderCrest {16} " +
                                 "HeadPl3={17} " +
                                 "HeadPl4={18}",
                                 Location.Name, 
                                 LocationScenarioID, 
                                 RiverLevel,
                                 RiverLevelLow.HasValue ? RiverLevelLow.ToString() : "?",
                                 DikeTableHeight.HasValue ? DikeTableHeight.ToString() : "?",
                                 ModelFactors.RequiredSafetyFactorStabilityInnerSlope.HasValue ? ModelFactors.RequiredSafetyFactorStabilityInnerSlope.ToString() : "?",
                                 ModelFactors.RequiredSafetyFactorStabilityOuterSlope.HasValue ? ModelFactors.RequiredSafetyFactorStabilityOuterSlope.ToString() : "?",
                                 WaterHeightDecimeringsHoogte.HasValue ? WaterHeightDecimeringsHoogte.ToString() : "?",
                                 MaxWaterLevel.HasValue ? MaxWaterLevel.ToString() : "?",
                                 PlLineOffsetBelowDikeTopAtRiver.HasValue ? PlLineOffsetBelowDikeToeAtPolder.ToString() : "?",
                                 PlLineOffsetBelowDikeToeAtPolder.HasValue ? MaxWaterLevel.ToString() : "?",
                                 PlLineOffsetBelowDikeTopAtPolder.HasValue ? PlLineOffsetBelowDikeTopAtPolder.ToString() : "?",
                                 PlLineOffsetBelowShoulderBaseInside.HasValue ? PlLineOffsetBelowShoulderBaseInside.ToString() : "?",
                                 UsePlLineOffsetBelowDikeCrestMiddle.HasValue ? UsePlLineOffsetBelowDikeCrestMiddle.ToString() : "?",
                                 PlLineOffsetBelowDikeCrestMiddle.HasValue ? PlLineOffsetBelowDikeCrestMiddle.ToString() : "?",
                                 UsePlLineOffsetFactorBelowShoulderCrest.HasValue ? UsePlLineOffsetFactorBelowShoulderCrest.ToString() : "?",
                                 PlLineOffsetFactorBelowShoulderCrest.HasValue ? PlLineOffsetFactorBelowShoulderCrest.ToString() : "?",
                                 HeadPl3.HasValue ? HeadPl3.ToString() : "?",
                                 HeadPl4.HasValue ? HeadPl4.ToString() : "?");
        }        
    }    
}