// Copyright (C) Stichting Deltares 2016. All rights reserved.
//
// This file is part of Ringtoets.
//
// Ringtoets is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU 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.Linq;
using Core.Common.Base;
using Core.Common.Base.Data;
using Ringtoets.Common.Data.Calculation;
using Ringtoets.Common.Data.Probabilistics;
using Ringtoets.HydraRing.Data;

namespace Ringtoets.GrassCoverErosionInwards.Data
{
    /// <summary>
    /// Class that holds all grass cover erosion inwards calculation specific input parameters.
    /// </summary>
    public class GrassCoverErosionInwardsInput : Observable, ICalculationInput
    {
        private readonly LogNormalDistribution criticalFlowRate;
        private RoundedDouble orientation;
        private RoundedDouble dikeHeight;

        /// <summary>
        /// Creates a new instance of <see cref="GrassCoverErosionInwardsInput"/>.
        /// </summary>
        public GrassCoverErosionInwardsInput()
        {
            orientation = new RoundedDouble(2);
            dikeHeight = new RoundedDouble(2);
            BreakWater = new BreakWater(BreakWaterType.Caisson, 0);
            criticalFlowRate = new LogNormalDistribution(4)
            {
                Mean = (RoundedDouble) 0.004,
                StandardDeviation = (RoundedDouble) 0.0006
            };
            DikeGeometry = Enumerable.Empty<RoughnessProfileSection>();
            ForeshoreGeometry = Enumerable.Empty<ProfileSection>();
        }

        /// <summary>
        /// Gets the dike's geometry (without foreshore geometry).
        /// </summary>
        public IEnumerable<RoughnessProfileSection> DikeGeometry { get; private set; }

        /// <summary>
        /// Gets the dike's foreshore geometry.
        /// </summary>
        public IEnumerable<ProfileSection> ForeshoreGeometry { get; private set; }

        /// <summary>
        /// Gets or sets the dike's orientation
        /// </summary>
        public RoundedDouble Orientation
        {
            get
            {
                return orientation;
            }
            set
            {
                orientation = value.ToPrecision(orientation.NumberOfDecimalPlaces);
            }
        }

        /// <summary>
        /// Gets or sets the dike's critical flow rate.
        /// </summary>
        public LogNormalDistribution CriticalFlowRate
        {
            get
            {
                return criticalFlowRate;
            }
            set
            {
                criticalFlowRate.Mean = value.Mean;
                criticalFlowRate.StandardDeviation = value.StandardDeviation;
            }
        }

        /// <summary>
        /// Gets or sets if <see cref="ForeshoreGeometry"/> needs to be taken into account.
        /// </summary>
        /// <remarks>Value of <see cref="ForeshoreGeometry"/> must not be reset when <see cref="UseForeshore"/> is set to <c>false</c>.</remarks>
        public bool UseForeshore { get; set; }

        /// <summary>
        /// Gets or sets the dike height.
        /// </summary>
        public RoundedDouble DikeHeight
        {
            get
            {
                return dikeHeight;
            }
            set
            {
                dikeHeight = value.ToPrecision(dikeHeight.NumberOfDecimalPlaces);
            }
        }

        /// <summary>
        /// Gets or sets if <see cref="BreakWater"/> needs to be taken into account.
        /// </summary>
        public bool UseBreakWater { get; set; }

        /// <summary>
        /// Gets the <see cref="BreakWater"/>.
        /// </summary>
        public BreakWater BreakWater { get; private set; }

        /// <summary>
        /// Gets or set the hydraulic boundary location from which to use the assessment level.
        /// </summary>
        public HydraulicBoundaryLocation HydraulicBoundaryLocation { get; set; }

        /// <summary>
        /// Sets the grass cover erosion inwards dike geometry.
        /// </summary>
        /// <param name="profileSections">The grass cover erosion inwards geometry points.</param>
        public void SetDikeGeometry(IEnumerable<RoughnessProfileSection> profileSections)
        {
            if (profileSections == null)
            {
                throw new ArgumentNullException("profileSections");
            }
            DikeGeometry = profileSections;
        }

        /// <summary>
        /// Sets the grass cover erosion inwards foreshore geometry.
        /// </summary>
        /// <param name="profileSections">The grass cover erosion inwards geometry points.</param>
        public void SetForeshoreGeometry(IEnumerable<ProfileSection> profileSections)
        {
            if (profileSections == null)
            {
                throw new ArgumentNullException("profileSections");
            }
            ForeshoreGeometry = profileSections;
        }
    }
}