//-----------------------------------------------------------------------
// <copyright file="PipingModel2Calculation.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T. The</author>
// <email>tom.the@deltares.nl</email>
// <date>8-9-2010</date>
// <summary></summary>
//-----------------------------------------------------------------------
namespace Deltares.Piping.Data
{
    using System;
    using System.Text;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Globalization;
    using Deltares.Standard;
    using Deltares.Standard.Language;
    using System.Collections.Generic;

    [StructLayout(LayoutKind.Sequential)]
    public struct RingDataStruct
    {
        public double WaterUnitWeight; //1
        public double WaterViscosity; //2
        public double ParticleUnitWeight; //3
        public double ParticleDiameter; //4
        public double Model2Layer1Thickness; //5
        public double Model2Layer2Thickness; //6
        public double Model2Soil1Permeability; //7
        public double Model2Soil2Permeability; //8
        public double Model2Soil3Permeability; //9
        public double VerticalSeepageLength; //10
        public double SeepageLength; //11
        public double BeddingAngle; //12
        public double WhitesConstant; //13
        public double SafetyFactor; //14
        public double FluidisationGradient; //15
    } ;

    [StructLayout(LayoutKind.Sequential)]
    public struct SoilPropertiesStruct
    {
        public double ParticleUnitWeight; //1
        public double ParticleD70; //2
        public double BeddingAngle; //3
        public double WhitesConstant; //4
    } ;

    [StructLayout(LayoutKind.Sequential)]
    public struct WaterPropertiesStruct
    {
        public double UnitWeight;
        public double Viscosity;
    } ;

    [StructLayout(LayoutKind.Sequential)]
    public struct CalculationParametersStruct
    {
        public int CalculationType; //1
        [MarshalAs(UnmanagedType.I1)] 
        public bool IsAdjustHeadDrop; //2
        public double SafetyFactor; //3
        public double FluidisationGradient; //4
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct ProbabilisticStruct
    {
        public ProbabilisticStruct(double mean, double standardDeviation, int distribution, bool isUsed)
        {
            Mean = mean;
            StandardDeviation = standardDeviation;
            Distribution = distribution;
            IsUsed = isUsed;
        }

        public double Mean; // 1
        public double StandardDeviation; // 2
        public int Distribution; // 3
        [MarshalAs(UnmanagedType.I1)] 
        public bool IsUsed; // 4
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct ProbabilisticSoilPropertiesStruct
    {
        public ProbabilisticStruct ProbParticleUnitWeight;
        public ProbabilisticStruct ProbParticleD70;
        public ProbabilisticStruct ProbBeddingAngle;
        public ProbabilisticStruct ProbWhitesConstant;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct ProbabilisticGeometryPropertiesStruct
    {
        public ProbabilisticStruct ProbSeepageLength;
        public ProbabilisticStruct ProbExternalWaterlevel;
        public ProbabilisticStruct ProbLayer1Thickness;
        public ProbabilisticStruct ProbLayer2Thickness;
        public ProbabilisticStruct ProbSoil1Permeability;
        public ProbabilisticStruct ProbSoil2Permeability;
        public ProbabilisticStruct ProbSoil3Permeability;
    }

    public class PipingModel2Calculation
    {
        private const string sPipingParametersSectionId = "[PipingParameters]";
        private const int cTotalParameterCount = 15;
        private const string sDebugFile = "VNK-Debug.log";
        private const int cMaxPath = 256;

        private PipingModelModel2Data fCurrentCalculationData = null;

        private string fHomeDir = "";

        private string fSessionId = "";

        public PipingModel2Calculation()
        {
            fCurrentCalculationData = new PipingModelModel2Data();            
        }

        public PipingModel2Calculation(ref PipingCommonData aPipingCommonData)
        {
            fCurrentCalculationData = new PipingModelModel2Data(ref aPipingCommonData);            
        }

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

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

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

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

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

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

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

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

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

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

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

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

        public string HomeDir
        {
            get { return fHomeDir; }
            set { fHomeDir = value; }
        }

        public string SessionId
        {
            get { return fSessionId; }
            set { fSessionId = value; }
        }

        public ProbabilisticStruct? ProbSeepageLength { get; set; }
        public ProbabilisticStruct? ProbExternalWaterlevel { get; set; }
        public ProbabilisticStruct? ProbLayer1Thickness { get; set; }
        public ProbabilisticStruct? ProbLayer2Thickness { get; set; }
        public ProbabilisticStruct? ProbSoil1Permeability { get; set; }
        public ProbabilisticStruct? ProbSoil2Permeability { get; set; }
        public ProbabilisticStruct? ProbSoil3Permeability { get; set; }

        public void CalculateHeadDropPCRing()
        {
            // clear the debug file flag
            //PCR_ClearDebugFlag();

            // fill the PCRingData struct
            RingDataStruct ringData = new RingDataStruct();
            double headDrop = 0.0;

            ringData.WaterUnitWeight = fCurrentCalculationData.PipingCommonData.WaterUnitWeight;
            ringData.WaterViscosity = fCurrentCalculationData.PipingCommonData.WaterViscosity;

            ringData.SeepageLength = fCurrentCalculationData.SeepageLength;
            ringData.VerticalSeepageLength = fCurrentCalculationData.CrackLength;

            ringData.ParticleUnitWeight = fCurrentCalculationData.PipingCommonData.ParticleUnitWeight;
            ringData.WhitesConstant = fCurrentCalculationData.PipingCommonData.WhitesConstant;
            ringData.BeddingAngle = fCurrentCalculationData.PipingCommonData.BeddingAngle;

            ringData.ParticleDiameter = fCurrentCalculationData.ParticleDiameter;

            ringData.Model2Layer1Thickness = fCurrentCalculationData.Height1;
            ringData.Model2Layer2Thickness = fCurrentCalculationData.Height2;

            ringData.Model2Soil1Permeability = fCurrentCalculationData.Permeability1;
            ringData.Model2Soil2Permeability = fCurrentCalculationData.Permeability2;
            ringData.Model2Soil3Permeability = fCurrentCalculationData.Permeability3;

            // set the debug flag
            PipingCalc2Dll.Model2PCRSetDebugFlag();

            StringBuilder LSb = new StringBuilder(cMaxPath);
            if (fSessionId == "")
                LSb.Append(fHomeDir + Path.DirectorySeparatorChar + fSessionId);
            else
                LSb.Append(fHomeDir + Path.DirectorySeparatorChar + sDebugFile);

            //LSb.Append('\0');

            PipingCalc2Dll.Model2PCRSetDebugFile(LSb.ToString());

            // call the calc dll
            int res;
            try
            {
                if (fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop)
                {
                    ringData.SafetyFactor = fCurrentCalculationData.PipingCommonData.SafetyFactor;
                    ringData.FluidisationGradient = fCurrentCalculationData.PipingCommonData.FluidisationGradient;

                    res = PipingCalc2Dll.Model2PCRCalculateHeadDrop /*PCR_CalcHeadDrop*/(ref ringData,
                                                                                         cTotalParameterCount,
                                                                                         ref headDrop);
                }
                else
                    res = PipingCalc2Dll.Model2PCRCalculateHeadDrop(ref ringData, cTotalParameterCount - 2, ref headDrop);
            }
            catch
            {
                res = 1;
            }

            string message = ReadDebugLog(LSb.ToString());

            // results
            if (res == 0)
            {
                fCurrentCalculationData.HeadDrop = headDrop;

                if (message == null)
                    fCurrentCalculationData.Messages = PipingConstants.CMessageGeen;
                else
                    fCurrentCalculationData.Messages = message;

                // archive the current set of input data and results
                PipingModelModel2Data LNewCalculatedData = new PipingModelModel2Data(fCurrentCalculationData);
            }
            else
            {
                fCurrentCalculationData.HeadDrop = 0.0;

                if (message == null)
                    fCurrentCalculationData.Messages = PipingConstants.CMessageError;
                else
                    fCurrentCalculationData.Messages = message;
            }
        }

        public void CalculateHeadDropPC2()
        {
            fCurrentCalculationData.Messages = "";
            var fCalcHandle = PipingCalc2Dll.Model2PC2CreateHandle();

            if (fCalcHandle == IntPtr.Zero)
            {
                fCurrentCalculationData.HeadDrop = 0.0;
                fCurrentCalculationData.Messages = PipingConstants.CMessageError;
                return;
            }
            bool result;
            try
            {
                // soil properties
                SoilPropertiesStruct soilProperties = new SoilPropertiesStruct();
                soilProperties.BeddingAngle = fCurrentCalculationData.PipingCommonData.BeddingAngle;
                soilProperties.ParticleD70 = fCurrentCalculationData.ParticleDiameter;
                soilProperties.ParticleUnitWeight = fCurrentCalculationData.PipingCommonData.ParticleUnitWeight;
                soilProperties.WhitesConstant = fCurrentCalculationData.PipingCommonData.WhitesConstant;
                PipingCalc2Dll.Model2PC2SetSoilProperties(fCalcHandle, soilProperties);

                // water properties
                WaterPropertiesStruct waterProperties = new WaterPropertiesStruct();
                waterProperties.UnitWeight = fCurrentCalculationData.PipingCommonData.WaterUnitWeight;
                waterProperties.Viscosity = fCurrentCalculationData.PipingCommonData.WaterViscosity;
                PipingCalc2Dll.Model2PC2SetWaterProperties(fCalcHandle, waterProperties);

                PipingCalc2Dll.Model2PC2SetCrackLength(fCalcHandle, fCurrentCalculationData.CrackLength);

                PipingCalc2Dll.Model2PC2SetHeadDrop(fCalcHandle, fCurrentCalculationData.HeadDrop);
                PipingCalc2Dll.Model2PC2SetSeepageLength(fCalcHandle, fCurrentCalculationData.SeepageLength);

                // heights
                double[] heightArray = new double[2];
                heightArray[0] = fCurrentCalculationData.Height1;
                heightArray[1] = fCurrentCalculationData.Height2;
                PipingCalc2Dll.Model2PC2SetHeights(fCalcHandle, heightArray.Length, heightArray);

                // permeabilities
                double[] permeabilityArray = new double[3];
                permeabilityArray[0] = fCurrentCalculationData.Permeability1;
                permeabilityArray[1] = fCurrentCalculationData.Permeability2;
                permeabilityArray[2] = fCurrentCalculationData.Permeability3;
                PipingCalc2Dll.Model2PC2SetPermeabilities(fCalcHandle, permeabilityArray.Length, permeabilityArray);

                //calculation parameters
                CalculationParametersStruct calculationParameters = new CalculationParametersStruct();
                if (fCurrentCalculationData.IsHeadDropCalculation == true)
                    calculationParameters.CalculationType = 1;
                else
                    calculationParameters.CalculationType = 2;
                calculationParameters.FluidisationGradient =
                    fCurrentCalculationData.PipingCommonData.FluidisationGradient;
                calculationParameters.IsAdjustHeadDrop = fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop;
                // Note: next safety factor only relevant when IsAdjustHeadDrop is true.
                calculationParameters.SafetyFactor = fCurrentCalculationData.PipingCommonData.SafetyFactor;
                PipingCalc2Dll.Model2PC2SetCalculationParameters(fCalcHandle, calculationParameters);

                // calculate
                result = true;
                try
                {
                    //if (fCurrentCalculationData.IsHeadDropCalculation == true)
                    //    fCurrentCalculationData.HeadDrop = Double.NaN;
                    //else
                    //    fCurrentCalculationData.SeepageLength = Double.NaN;
                    PipingCalc2Dll.Model2PC2Calculate(fCalcHandle);
                    if (fCurrentCalculationData.IsHeadDropCalculation == true)
                        fCurrentCalculationData.HeadDrop = PipingCalc2Dll.Model2PC2GetHeadDrop(fCalcHandle);
                    else
                        fCurrentCalculationData.SeepageLength = PipingCalc2Dll.Model2PC2GetSeepageLength(fCalcHandle);
                }
                catch
                {
                    throw new PipingCalculationException("Error in Piping DLL");
                }

                // results
                // Following call (Model2PC2GetCalculationMessages) is flawed and could result in a crash (string as return value raises issues with ownership of the memory)
                // So we comment it out
                // fCurrentCalculationData.WarningMessage = (PipingCalc2Dll.Model2PC2GetCalculationMessages(fCalcHandle));
                //if (fCurrentCalculationData.WarningMessage == "")
                //    fCurrentCalculationData.Messages = LanguageSupport.GetText("CMessageGeen",
                //                                                               System.Threading.Thread.CurrentThread.
                //                                                                   CurrentCulture);
                //else
                //    fCurrentCalculationData.Messages = fCurrentCalculationData.WarningMessage;
                fCurrentCalculationData.Messages = "";

                if (Double.IsNaN(fCurrentCalculationData.HeadDrop) || result == false)
                    fCurrentCalculationData.Messages = LanguageSupport.GetText("CMessageError",
                                                                               System.Threading.Thread.CurrentThread.
                                                                                   CurrentCulture);
            }
            finally
            {
                // cleanup
                PipingCalc2Dll.Model2PC2DestroyHandle(fCalcHandle);
            }

            // archive the current set of input data and results
            if (Double.IsNaN(fCurrentCalculationData.HeadDrop) == false && result == true)
            {
                PipingModelModel2Data LNewCalculatedData = new PipingModelModel2Data(fCurrentCalculationData);
            }
        }

        /// <summary>
        /// Throw helper
        /// </summary>
        /// <param name="currentObject"></param>
        public void ThrowIfNotAssigned(Object currentObject, string objectName)
        {
            if (currentObject == null)
            {
                throw new PipingCalculationException(string.Format("Missing input {0}", objectName));
            }
        }

        /// <summary>
        /// Check if alll probabilistic input available
        /// </summary>
        public void ThrowsIfProbabilisticInputInComplete()
        {
            ThrowIfNotAssigned(PipingCommonData, "PipingCommonData");
            ThrowIfNotAssigned(PipingCommonData.ProbBeddingAngle, "ProbBeddingAngle");
            ThrowIfNotAssigned(PipingCommonData.ProbParticleD70, "ProbParticleD70");
            ThrowIfNotAssigned(PipingCommonData.ProbParticleUnitWeight, "ProbParticleUnitWeight");
            ThrowIfNotAssigned(PipingCommonData.ProbWhitesConstant, "ProbWhitesConstant");
            ThrowIfNotAssigned(ProbSeepageLength, "ProbSeepageLength");
            ThrowIfNotAssigned(ProbExternalWaterlevel, "ProbExternalWaterlevel");
            ThrowIfNotAssigned(ProbLayer1Thickness, "ProbLayer1Thickness");
            ThrowIfNotAssigned(ProbLayer2Thickness, "ProbLayer2Thickness");
            ThrowIfNotAssigned(ProbSoil1Permeability, "ProbSoil1Permeability");
            ThrowIfNotAssigned(ProbSoil2Permeability, "ProbSoil2Permeability");
            ThrowIfNotAssigned(ProbSoil3Permeability, "ProbSoil3Permeability");
        }

        /// <summary>
        /// Calculate reliability index
        /// </summary>
        /// <returns></returns>
        public double CalculateReliabilityIndex()
        {
            ThrowsIfProbabilisticInputInComplete();
            fCurrentCalculationData.Messages = "";
            var fCalcHandle = PipingCalc2Dll.Model2PC2CreateHandle();

            if (fCalcHandle == IntPtr.Zero)
            {
                fCurrentCalculationData.HeadDrop = 0.0;
                fCurrentCalculationData.Messages = PipingConstants.CMessageError;
                throw new PipingCalculationException(
                    "Cannot create calculation handle for MPipingCalc2Dll in CalculateReliabilityIndex()");
            }

            double reliabilityIndex = 0.0;
            try
            {
                // soil properties
                var probabilisticSoilPropertiesStruct = new ProbabilisticSoilPropertiesStruct();
                probabilisticSoilPropertiesStruct.ProbBeddingAngle = PipingCommonData.ProbBeddingAngle.Value;
                probabilisticSoilPropertiesStruct.ProbParticleD70 = PipingCommonData.ProbParticleD70.Value;
                probabilisticSoilPropertiesStruct.ProbParticleUnitWeight = PipingCommonData.ProbParticleUnitWeight.Value;
                probabilisticSoilPropertiesStruct.ProbWhitesConstant = PipingCommonData.ProbWhitesConstant.Value;
                PipingCalc2Dll.Model2SetProbabilisticSoilProperties(fCalcHandle, probabilisticSoilPropertiesStruct);

                // geometry properties
                var probabilisticGeometryPropertiesStruct = new ProbabilisticGeometryPropertiesStruct();
                probabilisticGeometryPropertiesStruct.ProbExternalWaterlevel = ProbExternalWaterlevel.Value;
                probabilisticGeometryPropertiesStruct.ProbLayer1Thickness = ProbLayer1Thickness.Value;
                probabilisticGeometryPropertiesStruct.ProbLayer2Thickness = ProbLayer2Thickness.Value;
                probabilisticGeometryPropertiesStruct.ProbSeepageLength = ProbSeepageLength.Value;
                probabilisticGeometryPropertiesStruct.ProbSoil1Permeability = ProbSoil1Permeability.Value;
                probabilisticGeometryPropertiesStruct.ProbSoil2Permeability = ProbSoil2Permeability.Value;
                probabilisticGeometryPropertiesStruct.ProbSoil3Permeability = ProbSoil3Permeability.Value;
                PipingCalc2Dll.Model2SetProbabilisticGeometryProperties(fCalcHandle,
                                                                        probabilisticGeometryPropertiesStruct);

                // water properties
                WaterPropertiesStruct waterProperties = new WaterPropertiesStruct();
                waterProperties.UnitWeight = fCurrentCalculationData.PipingCommonData.WaterUnitWeight;
                waterProperties.Viscosity = fCurrentCalculationData.PipingCommonData.WaterViscosity;
                PipingCalc2Dll.Model2PC2SetWaterProperties(fCalcHandle, waterProperties);

                PipingCalc2Dll.Model2PC2SetCrackLength(fCalcHandle, fCurrentCalculationData.CrackLength);

                //calculation parameters
                CalculationParametersStruct calculationParameters = new CalculationParametersStruct();
                if (fCurrentCalculationData.IsHeadDropCalculation == true)
                    calculationParameters.CalculationType = 1;
                else
                    calculationParameters.CalculationType = 2;
                calculationParameters.FluidisationGradient =
                    fCurrentCalculationData.PipingCommonData.FluidisationGradient;
                calculationParameters.IsAdjustHeadDrop = fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop;
                calculationParameters.SafetyFactor = fCurrentCalculationData.PipingCommonData.SafetyFactor;
                PipingCalc2Dll.Model2PC2SetCalculationParameters(fCalcHandle, calculationParameters);

                // calculate
                PipingCalc2Dll.Model2CalculateProbabilistic(fCalcHandle);
                reliabilityIndex = PipingCalc2Dll.Model2GetReliabilityIndex(fCalcHandle);
                if (reliabilityIndex == -1.0)
                {
                    throw new PipingCalculationException("Error in Piping DLL (Beta = -1.0)");
                }

                // results
                fCurrentCalculationData.WarningMessage = (PipingCalc2Dll.Model2PC2GetCalculationMessages(fCalcHandle));

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

                if (Double.IsNaN(reliabilityIndex))
                    fCurrentCalculationData.Messages = LanguageSupport.GetText("CMessageError",
                                                                               System.Threading.Thread.CurrentThread.
                                                                                   CurrentCulture);
            }
            catch (Exception e)
            {
                throw new PipingCalculationException(string.Format("Error in Piping DLL {0}", e.Message));
            }
            finally
            {
                // cleanup
                PipingCalc2Dll.Model2PC2DestroyHandle(fCalcHandle);
            }

            return reliabilityIndex;
        }

        /// <summary>
        /// Read debug log from file
        /// </summary>
        /// <param name="APath"></param>
        /// <returns></returns>
        private string ReadDebugLog(string APath)
        {
            try
            {
                StreamReader stream = File.OpenText(APath);
                stream.ReadLine(); // first line

                string LLine2 = stream.ReadToEnd();
                stream.Close();
                File.Delete(APath);

                return LLine2;
            }
            catch
            {
                return null;
            }
        }

        // TEMP... this has to be done more generically
        private void SetCurrentValueFromString(string aField, string aValue)
        {
            double doubleValue = 0.0;
            bool boolValue = true;

            switch (aField)
            {
                case "gamma_w":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.WaterUnitWeight = doubleValue;
                        break;
                    }
                case "mu":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinWaterViscosity,
                                                            PipingConstants.CMaxWaterViscosity, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.WaterViscosity = doubleValue;
                        break;
                    }
                case "gamma_p":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.ParticleUnitWeight = doubleValue;
                        break;
                    }
                case "eta":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinWhitesConstant,
                                                            PipingConstants.CMaxWhitesConstant, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.WhitesConstant = doubleValue;
                        break;
                    }
                case "theta":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinBeddingAngle,
                                                            PipingConstants.CMaxBeddingAngle, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.BeddingAngle = doubleValue;
                        break;
                    }
                case "Adapt":
                    {
                        if (GetBoolValueFromString(aValue, ref boolValue))
                            fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop = boolValue;
                        break;
                    }
                case "F":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinSafetyFactor,
                                                            PipingConstants.CMaxSafetyFactor, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.SafetyFactor = doubleValue;
                        break;
                    }
                case "i":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CMinFluidisationGradient,
                                                            PipingConstants.CMaxFluidisationGradient, ref doubleValue))
                            fCurrentCalculationData.PipingCommonData.FluidisationGradient = doubleValue;
                        break;
                    }
                case "D1":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.Height1 = doubleValue;
                        break;
                    }
                case "D2":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.Height2 = doubleValue;
                        break;
                    }
                case "K1":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.Permeability1 = doubleValue;
                        break;
                    }
                case "K2":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.Permeability2 = doubleValue;
                        break;
                    }
                case "K3":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.Permeability3 = doubleValue;
                        break;
                    }
                case "Do":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, 0.0, PipingConstants.CDelphiMaxDouble,
                                                            ref doubleValue))
                            fCurrentCalculationData.CrackLength = doubleValue;
                        break;
                    }
                case "d70":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.ParticleDiameter = doubleValue;
                        break;
                    }
                case "L":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.SeepageLength = doubleValue;
                        break;
                    }
                case "dH":
                    {
                        if (ValidateDoubleToRangeFromString(aValue, PipingConstants.CNoiseTolerance,
                                                            PipingConstants.CDelphiMaxDouble, ref doubleValue))
                            fCurrentCalculationData.HeadDrop = doubleValue;
                        break;
                    }
                case "Calculate":
                    {
                        if (aValue == PipingModelModel2Data.RowHeaderTextList[15])
                            fCurrentCalculationData.IsHeadDropCalculation = false;
                        else
                            fCurrentCalculationData.IsHeadDropCalculation = true;
                        break;
                    }
                default:
                    break;
            }
        }

        // TEMP... this has to be done more generically
        private bool ValidateDoubleToRangeFromString(string aStringValue, double aMin, double aMax, ref double aValue)
        {
            double doubleValue = 0.0;

            // the CSV read would have changed all decimal separators to '.'
            // specify this to the double parsing, else we'd get wrong values
            // if the current thread has a diff decimal separator
            NumberFormatInfo ni = new NumberFormatInfo();
            ni.CurrencyDecimalSeparator = ".";
            ni.NumberDecimalSeparator = ".";

            try
            {
                doubleValue = Double.Parse(aStringValue, ni);
            }
            catch
            {
                return false;
            }

            if (doubleValue < aMin)
                doubleValue = aMin;
            else if (doubleValue > aMax)
                doubleValue = aMax;

            aValue = doubleValue;
            return true;
        }

        private bool GetBoolValueFromString(string aStringValue, ref bool aValue)
        {
            bool boolValue = true;

            try
            {
                boolValue = bool.Parse(aStringValue);
            }
            catch
            {
                return false;
            }

            aValue = boolValue;
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public List<string> ParametersDeterministicToStrings()
        {
            List<string> parameterStrings = new List<string>();

            // soil properties
            parameterStrings.Add(sPipingParametersSectionId);
            parameterStrings.Add(String.Format("BeddingAngle={0}", fCurrentCalculationData.PipingCommonData.BeddingAngle));
            parameterStrings.Add(String.Format("ParticleDiameter={0}", fCurrentCalculationData.ParticleDiameter));
            parameterStrings.Add(String.Format("ParticleUnitWeight={0:0.00}",
                                               fCurrentCalculationData.PipingCommonData.ParticleUnitWeight));
            parameterStrings.Add(String.Format("WhitesConstant={0}",
                                               fCurrentCalculationData.PipingCommonData.WhitesConstant));
            //// water properties
            parameterStrings.Add(String.Format("WaterUnitWeight={0:0.00}",
                                               fCurrentCalculationData.PipingCommonData.WaterUnitWeight));
            parameterStrings.Add(String.Format("WaterViscosity={0:E4}",
                                               fCurrentCalculationData.PipingCommonData.WaterViscosity));

            parameterStrings.Add(String.Format("CrackLength={0:0.00}", fCurrentCalculationData.CrackLength));
            parameterStrings.Add(String.Format("HeadDrop={0:0.00}", fCurrentCalculationData.HeadDrop));
            parameterStrings.Add(String.Format("SeepageLength={0:0.00}", fCurrentCalculationData.SeepageLength));

            //// heights
            parameterStrings.Add(String.Format("Height1={0:0.00}", fCurrentCalculationData.Height1));
            parameterStrings.Add(String.Format("Height2={0:0.00}", fCurrentCalculationData.Height2));
            //// permeabilities
            parameterStrings.Add(String.Format("Permeability1={0:E5}", fCurrentCalculationData.Permeability1));
            parameterStrings.Add(String.Format("Permeability2={0:E5}", fCurrentCalculationData.Permeability2));
            parameterStrings.Add(String.Format("Permeability3={0:E5}", fCurrentCalculationData.Permeability3));

            parameterStrings.Add(String.Format("IsHeadDropCalculation={0}",
                                               fCurrentCalculationData.IsHeadDropCalculation));
            parameterStrings.Add(String.Format("IsAdjustHeadDrop={0}",
                                               fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop));
            parameterStrings.Add(String.Format("SafetyFactor={0:0.00}",
                                               fCurrentCalculationData.PipingCommonData.SafetyFactor));
            parameterStrings.Add(String.Format("FluidisationGradient={0:0.00}",
                                               fCurrentCalculationData.PipingCommonData.FluidisationGradient));

            return parameterStrings;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public List<string> ParametersProbabilisticToStrings()
        {
            List<string> parameterStrings = new List<string>();

            // Make sure data is written in neutral format
            NumberFormatInfo numberFormatInfo = new NumberFormatInfo();
            numberFormatInfo.CurrencyDecimalSeparator = ".";
            numberFormatInfo.NumberDecimalSeparator = ".";

            // soil properties
            parameterStrings.Add(sPipingParametersSectionId);
            parameterStrings.Add(String.Format(numberFormatInfo, "BeddingAngleMean={0:0.000000}",
                                               PipingCommonData.ProbBeddingAngle.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "BeddingAngleStd={0:0.000000}",
                                               PipingCommonData.ProbBeddingAngle.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "BeddingAngleDist={0}",
                                               PipingCommonData.ProbBeddingAngle.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleDiameterMean={0:0.000000}",
                                               PipingCommonData.ProbParticleD70.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleDiameterStd={0:0.000000}",
                                               PipingCommonData.ProbParticleD70.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleDiameterDist={0}",
                                               PipingCommonData.ProbParticleD70.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleUnitWeightMean={0:0.000000}",
                                               PipingCommonData.ProbParticleUnitWeight.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleUnitWeightStd={0:0.000000}",
                                               PipingCommonData.ProbParticleUnitWeight.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "ParticleUnitWeightDist={0}",
                                               PipingCommonData.ProbParticleUnitWeight.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "WhitesConstantMean={0:0.000000}",
                                               PipingCommonData.ProbWhitesConstant.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "WhitesConstantStd={0:0.000000}",
                                               PipingCommonData.ProbWhitesConstant.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "WhitesConstantDist={0}",
                                               PipingCommonData.ProbWhitesConstant.Value.Distribution));
            // water properties
            parameterStrings.Add(String.Format(numberFormatInfo, "WaterUnitWeight={0:0.000000}",
                                               fCurrentCalculationData.PipingCommonData.WaterUnitWeight));
            parameterStrings.Add(String.Format(numberFormatInfo, "WaterViscosity={0:E4}",
                                               fCurrentCalculationData.PipingCommonData.WaterViscosity));

            parameterStrings.Add(String.Format(numberFormatInfo, "CrackLength={0:0.000000}",
                                               fCurrentCalculationData.CrackLength));
            parameterStrings.Add(String.Format(numberFormatInfo, "ExternalWaterlevelMean={0:0.000000}",
                                               ProbExternalWaterlevel.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "ExternalWaterlevelStd={0:0.000000}",
                                               ProbExternalWaterlevel.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "ExternalWaterlevelDist={0}",
                                               ProbExternalWaterlevel.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "SeepageLengthMean={0:0.000000}",
                                               ProbSeepageLength.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "SeepageLengthStd={0:0.000000}",
                                               ProbSeepageLength.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "SeepageLengthDist={0}",
                                               ProbSeepageLength.Value.Distribution));

            // heights
            parameterStrings.Add(String.Format(numberFormatInfo, "Height1Mean={0:0.000000}",
                                               ProbLayer1Thickness.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "Height1Std={0:0.000000}",
                                               ProbLayer1Thickness.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "Height1Dist={0}",
                                               ProbLayer1Thickness.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "Height2Mean={0:0.000000}",
                                               ProbLayer2Thickness.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "Height2Std={0:0.000000}",
                                               ProbLayer2Thickness.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "Height2Dist={0}",
                                               ProbLayer2Thickness.Value.Distribution));

            // permeabilities
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability1Mean={0:E7}",
                                               ProbSoil1Permeability.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability1Std={0:E7}",
                                               ProbSoil1Permeability.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability1Dist={0}",
                                               ProbSoil1Permeability.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability2Mean={0:E7}",
                                               ProbSoil2Permeability.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability2Std={0:E7}",
                                               ProbSoil2Permeability.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability2Dist={0}",
                                               ProbSoil2Permeability.Value.Distribution));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability3Mean={0:E7}",
                                               ProbSoil3Permeability.Value.Mean));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability3Std={0:E7}",
                                               ProbSoil3Permeability.Value.StandardDeviation));
            parameterStrings.Add(String.Format(numberFormatInfo, "Permeability3Dist={0}",
                                               ProbSoil3Permeability.Value.Distribution));

            parameterStrings.Add(String.Format(numberFormatInfo, "IsHeadDropCalculation={0}",
                                               fCurrentCalculationData.IsHeadDropCalculation));
            parameterStrings.Add(String.Format(numberFormatInfo, "IsAdjustHeadDrop={0}",
                                               fCurrentCalculationData.PipingCommonData.IsAdjustHeadDrop));
            parameterStrings.Add(String.Format(numberFormatInfo, "SafetyFactor={0:0.000000}",
                                               fCurrentCalculationData.PipingCommonData.SafetyFactor));
            parameterStrings.Add(String.Format(numberFormatInfo, "FluidisationGradient={0:0.000000}",
                                               fCurrentCalculationData.PipingCommonData.FluidisationGradient));

            return parameterStrings;
        }
    }
}