//-----------------------------------------------------------------------
// <copyright file="PipingModel3Calculation.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>7-7-2009</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------
using Deltares.Standard.Language;

namespace Deltares.Piping.Data
{
    using System;
    using System.Threading;
    using Deltares.Standard;

    public class PipingModel3Calculation
    {
        private readonly PipingModelModel3Data currentCalculationData;
        private IntPtr calculationHandle = IntPtr.Zero;

        /// <summary>
        /// Standard constructor
        /// </summary>
        public PipingModel3Calculation()
        {
            SessionId = "";
            HomeDir = "";
            currentCalculationData = new PipingModelModel3Data();
            calculationHandle = IntPtr.Zero;
        }

        /// <summary>
        /// Constructor with initializing values
        /// </summary>
        /// <param name="pipingCommonData"></param>
        public PipingModel3Calculation(PipingCommonData pipingCommonData)
        {
            SessionId = "";
            HomeDir = "";
            currentCalculationData = new PipingModelModel3Data(pipingCommonData);
            calculationHandle = IntPtr.Zero;
        }

        // wrap the Model2 data as properties here again (VNK)
        public PipingCommonData PipingCommonData
        {
            set { currentCalculationData.PipingCommonData = value; }
            get { return currentCalculationData.PipingCommonData; }
        }

        public bool IsHeadDropCalculation
        {
            set { currentCalculationData.IsHeadDropCalculation = value; }
            get { return currentCalculationData.IsHeadDropCalculation; }
        }

        public double SeepageLength
        {
            set { currentCalculationData.SeepageLength = value; }
            get { return currentCalculationData.SeepageLength; }
        }

        public double CrackLength
        {
            set { currentCalculationData.CrackLength = value; }
            get { return currentCalculationData.CrackLength; }
        }

        public double ParticleDiameter
        {
            set { currentCalculationData.ParticleDiameter = value; }
            get { return currentCalculationData.ParticleDiameter; }
        }

        public double Height1
        {
            set { currentCalculationData.Height1 = value; }
            get { return currentCalculationData.Height1; }
        }

        public double Height2
        {
            set { currentCalculationData.Height2 = value; }
            get { return currentCalculationData.Height2; }
        }

        public double Permeability1
        {
            set { currentCalculationData.Permeability1 = value; }
            get { return currentCalculationData.Permeability1; }
        }

        public double Permeability2
        {
            set { currentCalculationData.Permeability2 = value; }
            get { return currentCalculationData.Permeability2; }
        }

        public double Permeability3
        {
            set { currentCalculationData.Permeability3 = value; }
            get { return currentCalculationData.Permeability3; }
        }

        public double HeadDrop
        {
            get { return currentCalculationData.HeadDrop; }
            set { currentCalculationData.HeadDrop = value; }
        }

        public double HeadDropWell
        {
            get { return currentCalculationData.HeadDropWell; }
            set { currentCalculationData.HeadDropWell = value; }
        }

        public double WellContent
        {
            get { return currentCalculationData.WellContent; }
            set { currentCalculationData.WellContent = value; }
        }

        public string Messages
        {
            get { return currentCalculationData.Messages; }
            set { currentCalculationData.Messages = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        public string HomeDir { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string SessionId { get; set; }

        /// <summary>
        /// Actual piping calculation
        /// </summary>
        public void CalculateHeadDropPC3()
        {
            currentCalculationData.Messages = "";
            calculationHandle = PipingCalc3Dll.Model3PC3CreateHandle();

            if (calculationHandle == IntPtr.Zero)
            {
                currentCalculationData.HeadDrop = 0.0;
                currentCalculationData.Messages = PipingConstants.CMessageError;
                return;
            }

            // soil properties
            var soilProperties = new SoilPropertiesStruct();
            soilProperties.BeddingAngle = currentCalculationData.PipingCommonData.BeddingAngle;
            soilProperties.ParticleD70 = currentCalculationData.ParticleDiameter;
            soilProperties.ParticleUnitWeight = currentCalculationData.PipingCommonData.ParticleUnitWeight;
            soilProperties.WhitesConstant = currentCalculationData.PipingCommonData.WhitesConstant;
            PipingCalc3Dll.Model3PC3SetSoilProperties(calculationHandle, soilProperties);

            // water properties
            var waterProperties = new WaterPropertiesStruct();
            waterProperties.UnitWeight = currentCalculationData.PipingCommonData.WaterUnitWeight;
            waterProperties.Viscosity = currentCalculationData.PipingCommonData.WaterViscosity;
            PipingCalc3Dll.Model3PC3SetWaterProperties(calculationHandle, waterProperties);
            PipingCalc3Dll.Model3PC3SetCrackLength(calculationHandle, currentCalculationData.CrackLength);
            PipingCalc3Dll.Model3PC3SetHeadDrop(calculationHandle, currentCalculationData.HeadDrop);
            PipingCalc3Dll.Model3PC3SetSeepageLength(calculationHandle, currentCalculationData.SeepageLength);
            PipingCalc3Dll.Model3PC3SetWellContent(calculationHandle, currentCalculationData.WellContent);

            // heights
            var heightArray = new double[2];
            heightArray[0] = currentCalculationData.Height1;
            heightArray[1] = currentCalculationData.Height2;
            PipingCalc3Dll.Model3PC3SetHeights(calculationHandle, heightArray.Length, heightArray);

            // permeabilities
            var permeabilityArray = new double[3];
            permeabilityArray[0] = currentCalculationData.Permeability1;
            permeabilityArray[1] = currentCalculationData.Permeability2;
            permeabilityArray[2] = currentCalculationData.Permeability3;
            PipingCalc3Dll.Model3PC3SetPermeabilities(calculationHandle, permeabilityArray.Length, permeabilityArray);

            //calculation parameters
            var calculationParameters = new CalculationParametersStruct();
            calculationParameters.CalculationType = currentCalculationData.IsHeadDropCalculation ? 1 : 2;
            calculationParameters.FluidisationGradient = currentCalculationData.PipingCommonData.FluidisationGradient;
            calculationParameters.IsAdjustHeadDrop = currentCalculationData.PipingCommonData.IsAdjustHeadDrop;
            calculationParameters.SafetyFactor = currentCalculationData.PipingCommonData.SafetyFactor;
            PipingCalc3Dll.Model3PC3SetCalculationParameters(calculationHandle, calculationParameters);

            // calculate
            var result = true;
            try
            {
                PipingCalc3Dll.Model3PC3Calculate(calculationHandle);
                if (currentCalculationData.IsHeadDropCalculation)
                {
                    currentCalculationData.HeadDrop = PipingCalc3Dll.Model3PC3GetHeadDrop(calculationHandle);
                    currentCalculationData.HeadDropWell = PipingCalc3Dll.Model3PC3GetHeadDropWell(calculationHandle);
                }
                else
                {
                    currentCalculationData.SeepageLength = PipingCalc3Dll.Model3PC3GetSeepageLength(calculationHandle);
                }
            }
            catch
            {
                result = false;
            }

            // results
            currentCalculationData.WarningMessage = (PipingCalc3Dll.Model3PC3GetCalculationMessages(calculationHandle));

            if (currentCalculationData.WarningMessage == "")
                currentCalculationData.Messages = LanguageSupport.GetText("CMessageGeen",
                                                                          Thread.CurrentThread.CurrentCulture);
            else
                currentCalculationData.Messages = currentCalculationData.WarningMessage;

            if (Double.IsNaN(currentCalculationData.HeadDrop) || result == false)
                currentCalculationData.Messages = LanguageSupport.GetText("CMessageError",
                                                                          Thread.CurrentThread.CurrentCulture);

            // cleanup
            PipingCalc3Dll.Model3PC3DestroyHandle(calculationHandle);
            calculationHandle = IntPtr.Zero;
        }
    }
}