// Copyright (C) Stichting Deltares 2018. 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 Deltares.DamEngine.Data.General.Sensors;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.General
{
    /// <summary>
    /// 
    /// </summary>
    public class DamFailureMechanismeCalculationSpecification
    {
        private FailureMechanismSystemType failureMechanismSystemType;
        private PipingModelType pipingModelType = PipingModelType.Sellmeijer4Forces;
        private Enum calculationModel; 
        private FailureMechanismParametersMStab failureMechanismParametersMStab;
        private static DamProjectType damProjectType;
        private StabilityKernelType stabilityKernelType = StabilityKernelType.DamClassic;
        private RegionalAssessmentScenarioJobSettings regionalAssessmentScenarioJobSettings;

        /// <summary>
        /// Initializes a new instance of the <see cref="DamFailureMechanismeCalculationSpecification"/> class.
        /// </summary>
        public DamFailureMechanismeCalculationSpecification()
        {
            //Todo interface
            failureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
            failureMechanismParametersMStab = new FailureMechanismParametersMStab();
            CalculationModel = failureMechanismParametersMStab.MStabParameters.Model;
            FailureMechanismParametersMStab.MStabParameters.GridPosition = MStabGridPosition.Right;
            regionalAssessmentScenarioJobSettings = new RegionalAssessmentScenarioJobSettings();
        }

        /// <summary>
        /// Gets or sets the failure mechanism parameters MStab.
        /// </summary>
        /// <value>
        /// The failure mechanism parameters for MStab.
        /// </value>
        public FailureMechanismParametersMStab FailureMechanismParametersMStab
        {
            get { return failureMechanismParametersMStab; } 
            set { failureMechanismParametersMStab = value; }
        }

        /// <summary>
        /// Gets or sets the type of the failure mechanism system.
        /// </summary>
        /// <value>
        /// The type of the failure mechanism system.
        /// </value>
        public FailureMechanismSystemType FailureMechanismSystemType
        {
            get { return failureMechanismSystemType; }
            set
            {
                if (failureMechanismSystemType != value)
                {
                    failureMechanismSystemType = value;
                    // To solve MWDAM-592, remember the current pipingmodeltype as this gets reset by setting the
                    // calculationmodel. Only switch it back when needed.
                    var oldPipingModelType = pipingModelType;
//                    foreach (Enum possibleModel in this.GetDomain("CalculationModel"))
//                    {
//                        this.CalculationModel = possibleModel;
//                        break;
//                    }  #Bka: I think this is only needed for the UI.
                    switch (failureMechanismSystemType)
                    {
                        case FailureMechanismSystemType.StabilityInside:
                            failureMechanismParametersMStab.MStabParameters.GridPosition = MStabGridPosition.Right;
                            break;
                        case FailureMechanismSystemType.StabilityOutside:
                            failureMechanismParametersMStab.MStabParameters.GridPosition = MStabGridPosition.Left;
                            break;
                        case FailureMechanismSystemType.Piping:
                            PipingModelType = oldPipingModelType;
                            break;
                    }                       
                }
            }
        }


        /// <summary>
        /// Gets or sets the type of the piping model.
        /// </summary>
        /// <value>
        /// The type of the piping model.
        /// </value>
        public PipingModelType PipingModelType
        {
            get { return pipingModelType; }
            set
            {
                pipingModelType = value;
                if (failureMechanismSystemType == FailureMechanismSystemType.Piping)
                {
                    CalculationModel = pipingModelType;
                }
            }
        }

        /// <summary>
        /// Gets or sets the type of the dam project.
        /// </summary>
        /// <value>
        /// The type of the dam project.
        /// </value>
        public static DamProjectType DamProjectType
        {
            get { return damProjectType; }
            set { damProjectType = value; }
        }

        /// <summary>
        /// The calculationmodel is only needed to support the selection of the modeltype in the UI. The dropdownlist
        /// in the UI depends on this. This set can be filled with any proper types (for piping, stabilty etc) for any 
        /// mechanisme instead of the fixed types per mechanisme.
        /// </summary>
        public Enum CalculationModel 
        {
            get { return calculationModel; } 
            set
            {
                calculationModel = value;
                if (value is PipingModelType)
                {
                    pipingModelType = (PipingModelType) value;
                }
                else
                {
                    failureMechanismParametersMStab.MStabParameters.Model = (MStabModelType)value;
                }                
            }
        }

        /// <summary>
        /// Gets or sets the type of the stability model.
        /// </summary>
        /// <value>
        /// The type of the stability model.
        /// </value>
        public MStabModelType StabilityModelType
        {
            get { return failureMechanismParametersMStab.MStabParameters.Model; }
            set
            {
                failureMechanismParametersMStab.MStabParameters.Model = value;
                if (failureMechanismSystemType != FailureMechanismSystemType.Piping)
                {
                    CalculationModel = value;
                }
            }
        }

        /// <summary>
        /// Gets or sets the type of the stability kernel.
        /// </summary>
        /// <value>
        /// The type of the stability kernel.
        /// </value>
        public StabilityKernelType StabilityKernelType
        {
            get { return stabilityKernelType; }
            set { stabilityKernelType = value; }
        }

        /// <summary>
        /// Gets or sets the assessment scenario job settings.
        /// </summary>
        /// <value>
        /// The assessment scenario job settings.
        /// </value>
        public RegionalAssessmentScenarioJobSettings AssessmentScenarioJobSettings
        {
            get
            {
                return regionalAssessmentScenarioJobSettings;
            }
            set
            {
                regionalAssessmentScenarioJobSettings = value;
            }
        }

        /// <summary>
        /// Assigns the specified dam failure mechanisme calculation.
        /// </summary>
        /// <param name="damFailureMechanismeCalculation">The dam failure mechanisme calculation.</param>
        public void Assign(DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculation)
        {
            this.FailureMechanismSystemType = damFailureMechanismeCalculation.failureMechanismSystemType;
            this.FailureMechanismParametersMStab.Assign(damFailureMechanismeCalculation.FailureMechanismParametersMStab.Clone());
          //assign interface
        }

        /// <summary>
        /// Clones this instance.
        /// </summary>
        /// <returns></returns>
        public DamFailureMechanismeCalculationSpecification Clone()
        {
            DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculation = new DamFailureMechanismeCalculationSpecification();

            damFailureMechanismeCalculation.Assign(this);

            return damFailureMechanismeCalculation;
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            string description = "";
            description += String.Format("{0}", StabilityKernelType);
            description += String.Format("{0}", this.FailureMechanismSystemType);
            if ((this.FailureMechanismSystemType == FailureMechanismSystemType.StabilityInside) ||
              (this.FailureMechanismSystemType == FailureMechanismSystemType.StabilityOutside))
            {
                //interface?
                description += String.Format(" ({0})", this.FailureMechanismParametersMStab.MStabParameters.Model);
            }

            return description;
        }

        /// <summary>
        /// Determines whether slip circle definition is undefined.
        /// </summary>
        /// <returns>
        ///   <c>true</c> if [is slip circle definition undefined]; otherwise, <c>false</c>.
        /// </returns>
        public bool IsSlipCircleDefinitionUndefined()
        {
            bool isSlipCircleDefinitionUndefined = (failureMechanismParametersMStab.MStabParameters.SlipCircleDefinition == null);
            if (!isSlipCircleDefinitionUndefined)
            {
                isSlipCircleDefinitionUndefined = (failureMechanismParametersMStab.MStabParameters.SlipCircleDefinition.UpliftVanLeftGridHorizontalPointCount == 0);
            }
            return isSlipCircleDefinitionUndefined;
        }

    }
}