using System;
using System.Collections.Generic;

namespace Deltares.DamPiping.ExitPointDeterminator
{
    /// <summary>
    /// Exception class for UpliftCalculator
    /// </summary>
    public class UpliftCalculatorException : Exception
    {
        public UpliftCalculatorException(string message) : base(message) {}
    }

    /// <summary>
    /// Class for calculating the Uplift output parameters
    /// </summary>
    public class UpliftCalculator
    {
        // Input parameters

        private double deltaPhiCu = Double.NaN;
        private double foSu = Double.NaN;
        private double hcu = Double.NaN;
        private double volumetricWeightOfWater = PipingConstants.UnitWeightOfWater;
        private double zu = Double.NaN;
//        private LanguageType language = LanguageType.Dutch;

//        /// <summary>
//        /// Language for (validation) messages
//        /// </summary>
//        public LanguageType Language
//        {
//            get { return language; }
//            set { language = value; }
//        }

        /// <summary>
        /// Gets or sets the volumic weight of water.
        /// </summary>
        /// <value>
        /// The volumic weight of water.
        /// </value>
        public double VolumetricWeightOfWater
        {
            get
            {
                return volumetricWeightOfWater;
            }
            set
            {
                volumetricWeightOfWater = value;
            }
        }

        /// <summary>
        /// Gets or sets the model factor uplift.
        /// </summary>
        /// <value>
        /// The model factor uplift.
        /// </value>
        public double ModelFactorUplift { get; set; }

        /// <summary>
        /// Gets or sets the effective stress.
        /// </summary>
        /// <value>
        /// The effective stress.
        /// </value>
        public double EffectiveStress { get; set; }

        /// <summary>
        /// Gets or sets the h-river.
        /// </summary>
        /// <value>
        /// The h river.
        /// </value>
        public double HRiver { get; set; }

        /// <summary>
        /// Gets or sets the phi-exit.
        /// </summary>
        /// <value>
        /// The phi exit.
        /// </value>
        public double PhiExit { get; set; }

        /// <summary>
        /// Gets or sets the R-Exit.
        /// </summary>
        /// <value>
        /// The r exit.
        /// </value>
        public double RExit { get; set; }

        /// <summary>
        /// Gets or sets the H-exit.
        /// </summary>
        /// <value>
        /// The h exit.
        /// </value>
        public double HExit { get; set; }

        public double PhiPolder { get; set; }

        // Output parameters

        /// <summary>
        /// Gets the Zu.
        /// </summary>
        /// <value>
        /// The Zu.
        /// </value>
        public double Zu
        {
            get
            {
                return zu;
            }
            set {}
        }

        /// <summary>
        /// Gets the Fo_su.
        /// </summary>
        /// <value>
        /// The fo su.
        /// </value>
        public double FoSu
        {
            get
            {
                return foSu;
            }
            set {}
        }

        /// <summary>
        /// Gets the delta phi cu.
        /// </summary>
        /// <value>
        /// The delta phi cu.
        /// </value>
        public double DeltaPhiCu
        {
            get
            {
                return deltaPhiCu;
            }
            set {}
        }

        /// <summary>
        /// Gets the hcu.
        /// </summary>
        /// <value>
        /// The hcu.
        /// </value>
        public double Hcu
        {
            get
            {
                return hcu;
            }
            set {}
        }

        /// <summary>
        /// Calculates the output parameters from the input.
        /// </summary>
        public void Calculate()
        {
//            var restoreLanguage = LocalizationManager.CurrentLanguage;
//            LocalizationManager.CurrentLanguage = Language;
//            var dumper = new XmlDumper();
            try
            {
//                DumpThis(dumper);

                if (EffectiveStress < 0)
                {
                    var message = Helper.Translate("EffectiveStressNegative");
                    throw new UpliftCalculatorException(message);
                }
                if (Math.Abs(RExit) < PipingConstants.Epsilon)
                {
                    var message = Helper.Translate("RexitIsZero");
                    throw new PipingException<UpliftCalculator>(message);
                }
                deltaPhiCu = EffectiveStress/VolumetricWeightOfWater;
                zu = ModelFactorUplift*deltaPhiCu - (PhiExit - HExit);
                DetermineFactorOfSafety();
                hcu = (deltaPhiCu + HExit - PhiPolder) / RExit + PhiPolder;
            }
            finally
            {
//                DumpThis(dumper);
//                LocalizationManager.CurrentLanguage = restoreLanguage;
            }
        }

        private void DetermineFactorOfSafety()
        {
            foSu = 0;

            var reducedDeltaPhiCu = ModelFactorUplift*deltaPhiCu;
            if (Math.Abs(reducedDeltaPhiCu) > PipingConstants.Epsilon)
            {
                foSu = reducedDeltaPhiCu / Math.Max(0, PhiExit - HExit);
            }
        }

        private void LogParameterIsNaN(IList<string> list, string paramName)
        {
            var msg = string.Format(Helper.Translate("NaNParameterError"), paramName);
            list.Add(msg);
        }

        /// <summary>
        /// Validates the input
        /// </summary>
        /// <returns>a filled list when errors are found else an empty list</returns>
        public List<string> Validate()
        {
//            var restoreLanguage = LocalizationManager.CurrentLanguage;
//            LocalizationManager.CurrentLanguage = Language;
            var errors = new List<string>();
//            var dumper = new XmlDumper();
            try
            {
//                DumpThis(dumper);
 
                if (double.IsNaN(VolumetricWeightOfWater))
                    LogParameterIsNaN(errors, "VolumetricWeightOfWater");
                if (double.IsNaN(ModelFactorUplift))
                    LogParameterIsNaN(errors, "ModelFactorUplift");
                if (double.IsNaN(EffectiveStress))
                    LogParameterIsNaN(errors, "EffectiveStress");
                if (double.IsNaN(HRiver))
                    LogParameterIsNaN(errors, "HRiver");
                if (double.IsNaN(PhiExit))
                    LogParameterIsNaN(errors, "PhiExit");
                if (double.IsNaN(RExit))
                    LogParameterIsNaN(errors, "RExit");
                if (double.IsNaN(HExit))
                    LogParameterIsNaN(errors, "HExit");
                if (double.IsNaN(PhiPolder))
                    LogParameterIsNaN(errors, "PhiPolder");

                if (Math.Abs(RExit) < PipingConstants.Epsilon)
                {
                    errors.Add(Helper.Translate("RexitIsZero"));
                }
            }
            finally
            {
//                DumpThis(dumper);
//                LocalizationManager.CurrentLanguage = restoreLanguage;
            }
            return errors;
        }

//        #region DebugOut
//        private bool isDebugOutputEnabled = false;
//
//        private void DumpThis(XmlDumper dumper)
//        {
//            if (isDebugOutputEnabled)
//            {
//                dumper.DumpObject(this);
//            }
//        }
//
//        /// <summary>
//        /// Enables debug-dumping to XML
//        /// </summary>
//        public void EnableDebugOutput()
//        {
//            isDebugOutputEnabled = true;
//        }
//
//        /// <summary>
//        /// Fills the data from debug file.
//        /// </summary>
//        public WTIUpliftCalculator FillFromDebugFile(string content)
//        {
//            var serializer = new Deltares.Standard.IO.Xml.XmlDeserializer();
//            if (!string.IsNullOrEmpty(content))
//            {
//                var res = (WTIUpliftCalculator) serializer.XmlDeserializeFromString(content);
//                return res;
//            }
//            return null;
//        }
//
//        /// <summary>
//        /// Gets the main result
//        /// </summary>
//        public string GetMainResult()
//        {
//            return "FoS = " + foSu.ToString();
//        }
//
//        #endregion
    }
}