using System;
using System.Collections;
using Deltares.Mathematics;

// =======================================================================================================================
// Class name:
//
// Description:    Gets the data from the user interface (geoemtry)
//
// Copyright (c) 1009-2010 Deltares
//
// Date        ID   Modification
// 2008-03-26  Best Created
// 2008-04-24  Best Routines calling to UI put in InterfaceCalls
// 1009-04-09  Best ZoneData added
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    public struct TIntersectWaterline
    {
        public bool IsPhreatic;
        public int WaterLineIndex;
        public double ZCoord;
    }

    // end TIntersectWaterline

    public class TInterfaceData
    {
        private TCalculationOptions FCalculationOptions;
        private TWaternet FCurrentWaternet;
        private double[] FDegreeOfConsolidationLoads;
        private double[][] FDegreeOfConsolidationSoil;
        private TEarthquakeData FEarthquake;
        private string FExePath = String.Empty;
        private TExternalLevelFrequency FExternallevelFrequency;
        private TForbiddenLine[] FForbiddenLines;
        private GeneticAlgorithmOptions FGeneticAlgorithmOptions = null;
        private TPoints[] FGeometryPoints;
        private TGeotextiles[] FGeotextiles;
        private THorizontalbalanceData FHorizontalBalanceData;
        private double[][] FInitialDegreeOfConsolidationSoil;
        private TStabSoilData[] FInitialStabSoilData;
        private TInterfaceCalls FInterfaceCalls = null;
        private TLayerRecord[] FLayers;
        private TLineLoad[] FLineLoad;
        private TModelData FModelData;
        private TNail[] FNail;
        private TProbabilisticDefaults FProbabilisticDefaults = null;
        private TSlipCircleData FSlipCircleData;
        private TSpencerPlaneData FSpencerPlaneData;
        private TStabSoilData[] FStabSoilData;
        private TStressTable[] FStressTable;
        private TPoints[] FSurfaceLine;
        private TTreeOnSlope FTreeOnSlope;
        private string FTutorialFileName = String.Empty;
        private TUniformLoad[] FUniformLoad;
        private TWaternet[] FWaternets;
        private TZoneData FZoneData;

        public TInterfaceData() : base()
        {
            // FillObject is static and can only be loaded once
            FInterfaceCalls = new TInterfaceCalls();
            // FGammaWater := 9.81;
        }

        public TPoints[] SurfaceLine
        {
            get
            {
                return FSurfaceLine;
            }
            set
            {
                FSurfaceLine = value;
            }
        }

        public TPoints[] GeometryPoints
        {
            get
            {
                return FGeometryPoints;
            }
            set
            {
                FGeometryPoints = value;
            }
        }

        // next all incorporated in waternets
        // property PLLines: TLinesArray read FPLLines write FPLLines;
        // property GammaWater: Double read FGammaWater write FGammaWater;
        // property WaterLines: TWaterLineArray read FWaterLines write FWaterLines;
        // property FreaticLineNumber: Integer read FFreaticLineNumber write FFreaticLineNumber;
        public TExternalLevelFrequency ExternallevelFrequency
        {
            get
            {
                return FExternallevelFrequency;
            }
            set
            {
                FExternallevelFrequency = value;
            }
        }

        public TWaternet[] Waternets
        {
            get
            {
                return FWaternets;
            }
            set
            {
                FWaternets = value;
            }
        }

        // For calculation purpose
        public TWaternet CurrentWaternet
        {
            get
            {
                return FCurrentWaternet;
            }
            set
            {
                FCurrentWaternet = value;
            }
        }

        public TLayerRecord[] Layers
        {
            get
            {
                return FLayers;
            }
            set
            {
                FLayers = value;
            }
        }

        public TSlipCircleData SlipCircleData
        {
            get
            {
                return FSlipCircleData;
            }
            set
            {
                FSlipCircleData = value;
            }
        }

        public TSpencerPlaneData SpencerPlaneData
        {
            get
            {
                return FSpencerPlaneData;
            }
            set
            {
                FSpencerPlaneData = value;
            }
        }

        public TCalculationOptions CalculationOptions
        {
            get
            {
                return FCalculationOptions;
            }
            set
            {
                FCalculationOptions = value;
            }
        }

        public GeneticAlgorithmOptions GeneticAlgorithmOptions
        {
            get
            {
                return FGeneticAlgorithmOptions;
            }
            set
            {
                FGeneticAlgorithmOptions = value;
            }
        }

        public TEarthquakeData Earthquake
        {
            get
            {
                return FEarthquake;
            }
            set
            {
                FEarthquake = value;
            }
        }

        public TGeotextiles[] Geotextiles
        {
            get
            {
                return FGeotextiles;
            }
            set
            {
                FGeotextiles = value;
            }
        }

        public TForbiddenLine[] ForbiddenLines
        {
            get
            {
                return FForbiddenLines;
            }
            set
            {
                FForbiddenLines = value;
            }
        }

        public TStabSoilData[] StabSoilData
        {
            get
            {
                return FStabSoilData;
            }
            set
            {
                FStabSoilData = value;
            }
        }

        public TUniformLoad[] UniformLoad
        {
            get
            {
                return FUniformLoad;
            }
            set
            {
                FUniformLoad = value;
            }
        }

        public TLineLoad[] LineLoad
        {
            get
            {
                return FLineLoad;
            }
            set
            {
                FLineLoad = value;
            }
        }

        public TNail[] Nail
        {
            get
            {
                return FNail;
            }
            set
            {
                FNail = value;
            }
        }

        public TTreeOnSlope TreeOnSlope
        {
            get
            {
                return FTreeOnSlope;
            }
            set
            {
                FTreeOnSlope = value;
            }
        }

        public TStressTable[] Stresstable
        {
            get
            {
                return FStressTable;
            }
            set
            {
                FStressTable = value;
            }
        }

        public TStressTable[] BondStresstable { get; set; }

        public TModelData ModelData
        {
            get
            {
                return FModelData;
            }
            set
            {
                FModelData = value;
            }
        }

        public TProbabilisticDefaults ProbabilisticDefaults
        {
            get
            {
                return FProbabilisticDefaults;
            }
            set
            {
                FProbabilisticDefaults = value;
            }
        }

        public TZoneData ZoneData
        {
            get
            {
                return FZoneData;
            }
            set
            {
                FZoneData = value;
            }
        }

        // procedure DumpCircleResults(ACentrePoints: TCentrePointsArray; var AMinCentrePoint, AMinCircle: Integer);
        public double[] DegreeOfConsolidationLoads
        {
            get
            {
                return FDegreeOfConsolidationLoads;
            }
            set
            {
                FDegreeOfConsolidationLoads = value;
            }
        }

        public double[][] DegreeOfConsolidationSoil
        {
            get
            {
                return FDegreeOfConsolidationSoil;
            }
            set
            {
                FDegreeOfConsolidationSoil = value;
            }
        }

        public TInterfaceCalls InterfaceCalls
        {
            get
            {
                return FInterfaceCalls;
            }
            set
            {
                FInterfaceCalls = value;
            }
        }

        // Delegate members
        // FSurfaceFromPointFunction: TSurfaceFromPointDelegate;
        // FIntersectWaterLinesFunction: TIntersectWaterLinesDelegate;
        // FIntersectHeadLineFunction: TIntersectHeadLineDelegate;
        // FIntersectLayersFunction: TIntersectLayersDelegate;
        // FIntersectPhreaticLineFunction: TIntersectPhreaticLineDelegate;
        // FCenterOfGravityFunction: TCenterOfGravityDelegate;
        // FPorePressureFunction: TPorePressureDelegate;
        // FZReferencelevelCuCalculatedFunction: TZReferencelevelCuCalculatedDelegate;

        // Properties and indexers cannot be read in C#
        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetEarthQuakeFactors(double AFreeWaterFactor, double AHorQuakeFactor, double AVerQuakeFactor)
        {
            FEarthquake.FreeWaterFactor = AFreeWaterFactor;
            FEarthquake.HorizontalQuakeFactor = AHorQuakeFactor;
            FEarthquake.VerticalQuakeFactor = AVerQuakeFactor;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetSlipCircleData(TSlipCircleData ASlipCircleData)
        {
            FSlipCircleData = ASlipCircleData;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TSlipCircleData GetSlipCircleData()
        {
            TSlipCircleData result;
            result = FSlipCircleData;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TSpencerPlaneData GetSpencerPlaneData()
        {
            TSpencerPlaneData result;
            result = FSpencerPlaneData;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetSpencerPlaneData(TSpencerPlaneData ASpencerPlaneData)
        {
            FSpencerPlaneData = ASpencerPlaneData;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TGeotextiles[] GetGeoTextiles()
        {
            TGeotextiles[] result;
            result = FGeotextiles;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetGeoTextiles(TGeotextiles[] AGeoTextiles)
        {
            FGeotextiles = AGeoTextiles;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TCalculationOptions GetCalculationOptions()
        {
            TCalculationOptions result;
            result = FCalculationOptions;
            if ((result.StriveSlice == 0))
            {
                result.StriveSlice = 30;
            }
            result.IsGridMoved = true;
            result.NumberOfAutogridMoves = 30;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetCalculationOptions(TCalculationOptions ACalculationOptions)
        {
            FCalculationOptions = ACalculationOptions;
            if ((FCalculationOptions.StriveSlice == 0))
            {
                FCalculationOptions.StriveSlice = 30;
            }
            //FCalculationOptions.IsGridMoved = ACalculationOptions.IsGridMoved;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TModelData GetModelData()
        {
            TModelData result;
            result = FModelData;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetModelData(TModelData AModelData)
        {
            FModelData = AModelData;
        }

        // (*Tijdelijk verplaatst naar interfacecalls.pas
        // procedure TInterfaceData.SetSurfaceFromPointDelegate(ASurfaceFromPoint: TSurfaceFromPointDelegate);
        // begin
        // FSurfaceFromPointFunction := ASurfaceFromPoint;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetIntersectHeadlineDelegate(AIntersectHeadline: TIntersectHeadlineDelegate);
        // begin
        // FIntersectHeadLineFunction := AIntersectHeadline;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetIntersectLayersDelegate(AIntersectLayer: TIntersectLayersDelegate);
        // begin
        // FIntersectLayersFunction := AIntersectLayer;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetIntersectPhreaticDelegate(AIntersectPhreatic: TIntersectPhreaticLineDelegate);
        // begin
        // FIntersectPhreaticLineFunction := AIntersectPhreatic;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetCenterGravityDelegate(ACenterGravity: TCenterOfGravityDelegate);
        // begin
        // FCenterOfGravityFunction := ACenterGravity;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetPorePressureDelegate(APorePressure: TPorePressureDelegate);
        // begin
        // FPorePressureFunction := APorePressure;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetReferenceLevelDelegate(AReferenceLevel: TZReferencelevelCuCalculatedDelegate);
        // begin
        // FZReferencelevelCuCalculatedFunction := AReferenceLevel;
        // end;
        //
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================}
        // procedure TInterfaceData.SetIntersectWaterlinesDelegate(AIntersectWaterlines: TIntersectWaterLinesDelegate);
        // begin
        // FIntersectWaterLinesFunction := AIntersectWaterlines;
        // end;
        // *)
        public THorizontalbalanceData GetHorizontalBalance()
        {
            THorizontalbalanceData result;
            result = FHorizontalBalanceData;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetHorizontalBalance(THorizontalbalanceData AHorizontalBalance)
        {
            FHorizontalBalanceData = AHorizontalBalance;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public TEarthquakeData GetEarthQuake()
        {
            TEarthquakeData result;
            result = Earthquake;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void SetEarthQuake(TEarthquakeData AEarthQuake)
        {
            FEarthquake = AEarthQuake;
        }

        public void PrepareSoilData()
        {
            int i;
            int j;
            bool LChangeIsIsExecuted;
            TStabSoilData LSoil;
            int LNDim;
            if ((FModelData.IsProbabilistic))
            {
                // Change the soil parameters if needed
                // For a deterministic mean or probabilistic calculation we need mean values
                // For a deterministic  design valu calculation we need design values
                // First reset soil data and degree of consolidation to initial values
                LNDim = FStabSoilData.Length;
                for (i = 0; i < LNDim; i ++)
                {
                    StabSoilData[i].Copy(FInitialStabSoilData[i]);
                }
                for (i = 0; i < LNDim; i ++)
                {
                    LChangeIsIsExecuted = false;

                    LSoil = StabSoilData[i];
                    if ((LSoil.ProbInputValues == TProbInputValuesSet.pivDesign) && (FCalculationOptions.ProbabilisticCalculationType != TProbCalculationType.pctDeterministicDesign))
                    {
                        DetermineMeanFromDesign(ref LSoil);
                        LChangeIsIsExecuted = true;
                    }
                    if (!LChangeIsIsExecuted)
                    {
                        if ((FCalculationOptions.ProbabilisticCalculationType == TProbCalculationType.pctDeterministicDesign) && (LSoil.ProbInputValues != TProbInputValuesSet.pivDesign))
                        {
                            DetermineDesignFromMean(ref LSoil);
                        }
                    }
                }
                LNDim = FDegreeOfConsolidationSoil.Length;
                for (i = 0; i < LNDim; i++)
                {
                    for (j = 0; j < LNDim; j++)
                    {
                        DegreeOfConsolidationSoil[i][j] = FInitialDegreeOfConsolidationSoil[i][j];
                    }
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-02  Best Created
        // =======================================================================================================================
        public void PrepareData()
        {
            int i;
            int j;
            int k;
            int LNLayers;
            int LNDim;
            TWaternet LWaternet;
            AddShortcutsToSoildata();
            InitialiseStressTableFactor();
            BackupSoilData();
            BackupDegreeOfconsolidationData();
            // TODO -obest -curgent : Replace this if modeldata is filed correctly
            FModelData.LeftSideIsActive = false;
            if ((FZoneData.StabilitySide == TStabilitySideSet.RightSide))
            {
                FModelData.LeftSideIsActive = true;
            }
            LNLayers = FLayers.Length;
            for (i = 1; i <= LNLayers; i ++)
            {
                Layers[i - 1].NumberOfLayerPoints = Layers[i - 1].Layerpoints.Count;
                LNDim = Layers[i - 1].NumberOfLayerPoints;
                Layers[i - 1].MinX = Layers[i - 1].Layerpoints[0].XCoor;
                Layers[i - 1].MaxX = Layers[i - 1].Layerpoints[0].XCoor;
                Layers[i - 1].MinZ = Layers[i - 1].Layerpoints[0].ZCoor;
                Layers[i - 1].MaxZ = Layers[i - 1].Layerpoints[0].ZCoor;
                for (j = 1; j < LNDim; j ++)
                {
                    Layers[i - 1].MinX = Math.Min(Layers[i - 1].MinX, Layers[i - 1].Layerpoints[j].XCoor);
                    Layers[i - 1].MaxX = Math.Max(Layers[i - 1].MaxX, Layers[i - 1].Layerpoints[j].XCoor);
                    Layers[i - 1].MinZ = Math.Min(Layers[i - 1].MinZ, Layers[i - 1].Layerpoints[j].ZCoor);
                    Layers[i - 1].MaxZ = Math.Max(Layers[i - 1].MaxZ, Layers[i - 1].Layerpoints[j].ZCoor);
                }
            }
            // Close the layers
            for (i = 1; i <= LNLayers; i ++)
            {
                Layers[i - 1].NumberOfLayerPoints ++;
                Layers[i - 1].Layerpoints.Add(new TPoints(Layers[i - 1].Layerpoints[0].XCoor, Layers[i - 1].Layerpoints[0].ZCoor));
            }
            // Calculate area of layers
            for (i = 1; i <= LNLayers; i ++)
            {
                Layers[i - 1].Area = Math.Abs(MStabDatafunctions.DetermineArea(Layers[i - 1].Layerpoints));
            }

            // Add surface lines to uniform loads
            if (FUniformLoad != null)
            {
                for (i = 1; i <= FUniformLoad.Length; i++)
                {
                    UniformLoad[i - 1].SurfaceLine = FSurfaceLine;
                }
            }

            // Calculate minimum and maximum values of waternet lines (to improve speed at calculation)
            for (k = FWaternets.GetLowerBound(0); k <= FWaternets.GetUpperBound(0); k ++)
            {
                LWaternet = Waternets[k];
                for (i = LWaternet.Waterlines.GetLowerBound(0); i <= LWaternet.Waterlines.GetUpperBound(0); i ++)
                {
                    LWaternet.Waterlines[i].MinX = LWaternet.Waterlines[i].Waterline[0].XCoor;
                    LWaternet.Waterlines[i].MinZ = LWaternet.Waterlines[i].Waterline[0].ZCoor;
                    LWaternet.Waterlines[i].MaxX = LWaternet.Waterlines[i].Waterline[LWaternet.Waterlines[i].Waterline.GetUpperBound(0)].XCoor;
                    LWaternet.Waterlines[i].MaxZ = LWaternet.Waterlines[i].Waterline[0].ZCoor;
                    for (j = LWaternet.Waterlines[i].Waterline.GetLowerBound(0); j <= LWaternet.Waterlines[i].Waterline.GetUpperBound(0); j ++)
                    {
                        LWaternet.Waterlines[i].MaxZ = Math.Max(LWaternet.Waterlines[i].Waterline[j].ZCoor, LWaternet.Waterlines[i].MaxZ);
                        LWaternet.Waterlines[i].MinZ = Math.Min(LWaternet.Waterlines[i].Waterline[j].ZCoor, LWaternet.Waterlines[i].MinZ);
                    }
                }
            }
        }

        public void Writeinterfacedata()
        {
            int i;
            int k;
            int l;
            int LNDim;
            int LNLayers;
            TWaterLineRecord LWaterLine;
            TPoints[] LPLLine;
            TWaternet LWaternet;
            LNDim = FSurfaceLine.Length;
            for (k = FWaternets.GetLowerBound(0); k <= FWaternets.GetUpperBound(0); k ++)
            {
                LWaternet = Waternets[k];
                // Head  Lines
                for (l = LWaternet.Waterlines.GetLowerBound(0); l <= LWaternet.Waterlines.GetUpperBound(0); l ++)
                {
                    LWaterLine = LWaternet.Waterlines[l];
                    LNDim = LWaterLine.Waterline.Length;
                    for (i = LWaternet.PLLines.GetLowerBound(0); i <= LWaternet.PLLines.GetUpperBound(0); i ++)
                    {
                        LPLLine = LWaternet.PLLines[i];
                        LNDim = LPLLine.Length;
                    }
                }
            }
            // different layers
            LNLayers = FLayers.Length;
            for (i = 1; i <= LNLayers; i ++)
            {
                Layers[i - 1].NumberOfLayerPoints = Layers[i - 1].Layerpoints.Count;
                LNDim = Layers[i - 1].NumberOfLayerPoints;
            }
            for (i = 1; i <= LNLayers; i ++)
            {
                LNDim = FDegreeOfConsolidationLoads.Length;
            }
            if ((LNDim == 0))
            {
                FDegreeOfConsolidationLoads = new double[LNLayers];
                for (i = FDegreeOfConsolidationLoads.GetLowerBound(0); i <= FDegreeOfConsolidationLoads.GetUpperBound(0); i ++)
                {
                    DegreeOfConsolidationLoads[i] = 100.0;
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-19  Manders Created
        // =======================================================================================================================
        public void SetExePath(string AExePath)
        {
            FExePath = AExePath;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2009-05-28  Mand Created
        // =======================================================================================================================
        public void SetTutorialFileName(string AFileName)
        {
            FTutorialFileName = AFileName;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2009-05-28  Mand Created
        // =======================================================================================================================
        public TZoneData GetZoneData()
        {
            TZoneData result;
            result = ZoneData;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2009-05-28  Mand Created
        // =======================================================================================================================
        public void SetZoneData(TZoneData AZoneData)
        {
            ZoneData = AZoneData;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================
        private void DetermineDesignFromMean(ref TStabSoilData ASoil)
        {
            TConvertTypeSet LConvert;
            TMatStrengthTypeSet LMaterialStrength;
            TSoilParameterConversion LSoilparameterConversion;
            LSoilparameterConversion = new TSoilParameterConversion();
            LMaterialStrength = ASoil.MaterialStrength;
            if ((new ArrayList(new TMatStrengthTypeSet[]
                {
                    TMatStrengthTypeSet.mstNone, TMatStrengthTypeSet.Default
                }).Contains(LMaterialStrength)))
            {
                LMaterialStrength = FModelData.DefaultStrength;
            }
            switch (LMaterialStrength)
            {
                case TMatStrengthTypeSet.mstCphi:
                    LConvert = TConvertTypeSet.ctCohesion;
                    ASoil.Cohesion = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctPhi;
                    ASoil.Phi = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstStressTab:
                case TMatStrengthTypeSet.mstPseudoStressTab:
                    ASoil.StresstableFactor = DetermineStresstableFactor(ASoil);
                    break;
                case TMatStrengthTypeSet.mstMeasuredCu:
                    LConvert = TConvertTypeSet.ctCuTop;
                    ASoil.CuTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuBottom;
                    ASoil.CuBottom = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveTop;
                    ASoil.CuPassiveTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveBottom;
                    ASoil.CuPassiveBottom = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveTop;
                    ASoil.CuActiveTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveBottom;
                    ASoil.CuActiveBottom = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstCalculatedCu:
                    LConvert = TConvertTypeSet.ctRatioCuPc;
                    ASoil.RatioCuPc = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRatioCuPcPassive;
                    ASoil.RatioCuPcPassive = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRatioCuPcActive;
                    ASoil.RatioCuPcActive = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveTop;
                    ASoil.CuPassiveTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveBottom;
                    ASoil.CuPassiveBottom = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveTop;
                    ASoil.CuActiveTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveBottom;
                    ASoil.CuActiveBottom = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctPop;
                    ASoil.POP = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRRatio;
                    ASoil.RRatio = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstGradientCu:
                    LConvert = TConvertTypeSet.ctCuGradientTop;
                    ASoil.CuTop = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuGradient;
                    ASoil.CuGradient = LSoilparameterConversion.GetDesignFromMean(LConvert, ASoil, FProbabilisticDefaults);
                    break;
            }
        }

        private double GetInputVariables(TConvertTypeSet AConvert, TStabSoilData ASoil)
        {
            double result;
            result = 0;
            switch (AConvert)
            {
                case TConvertTypeSet.ctCohesion:
                    result = ASoil.Cohesion;
                    break;
                case TConvertTypeSet.ctPhi:
                    result = ASoil.Phi;
                    break;
                case TConvertTypeSet.ctRatioCuPc:
                    result = ASoil.RatioCuPc;
                    break;
                case TConvertTypeSet.ctCuTop:
                    result = ASoil.CuTop;
                    break;
                case TConvertTypeSet.ctCuBottom:
                    result = ASoil.CuBottom;
                    break;
                case TConvertTypeSet.ctCuGradientTop:
                    result = ASoil.CuTop;
                    break;
                case TConvertTypeSet.ctCuGradient:
                    result = ASoil.CuGradient;
                    break;
                case TConvertTypeSet.ctRatioCuPcPassive:
                    result = ASoil.RatioCuPcPassive;
                    break;
                case TConvertTypeSet.ctRatioCuPcActive:
                    result = ASoil.RatioCuPcActive;
                    break;
                case TConvertTypeSet.ctCuPassiveTop:
                    result = ASoil.CuPassiveTop;
                    break;
                case TConvertTypeSet.ctCuPassiveBottom:
                    result = ASoil.CuPassiveBottom;
                    break;
                case TConvertTypeSet.ctCuActiveTop:
                    result = ASoil.CuActiveTop;
                    break;
                case TConvertTypeSet.ctCuActiveBottom:
                    result = ASoil.CuActiveBottom;
                    break;
                case TConvertTypeSet.ctStressTabFactor:
                    result = Constants.CNormValue;
                    break;
                case TConvertTypeSet.ctPop:
                    result = ASoil.POP;
                    break;
                case TConvertTypeSet.ctRRatio:
                    result = ASoil.RRatio;
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Decription  GetSoilParameterValue
        // Find or calculate the requested parameters
        //
        // Date        ID   Modification
        // 2003-09-10  Best Created.
        // =======================================================================================================================
        private double GetSoilParameterValue(TConvertTypeSet AConvert, TStabSoilData ASoil)
        {
            double result;
            TProbInputValuesSet LProbMethod;
            TSoilParameterConversion LSoilparameterConversion;
            // the prob input values are mostly not filled
            if ((ASoil.ProbInputValues == TProbInputValuesSet.pivNone))
            {
                LProbMethod = FModelData.DefaultInputValues;
            }
            else
            {
                LProbMethod = ASoil.ProbInputValues;
            }
            result = 0;
            if ((FModelData.IsProbabilistic))
            {
                LSoilparameterConversion = new TSoilParameterConversion();
                if ((FCalculationOptions.ProbabilisticCalculationType == TProbCalculationType.pctDeterministicMean) || (FCalculationOptions.ProbabilisticCalculationType == TProbCalculationType.pctProbabilistic))
                {
                    if ((LProbMethod == TProbInputValuesSet.pivMean))
                    {
                        result = GetInputVariables(AConvert, ASoil);
                    }
                    else
                    {
                        if ((GetInputVariables(AConvert, ASoil) > 0.001))
                        {
                            result = LSoilparameterConversion.GetMeanFromDesign(AConvert, ASoil, FProbabilisticDefaults);
                        }
                    }
                }
                if ((FCalculationOptions.ProbabilisticCalculationType == TProbCalculationType.pctDeterministicDesign))
                {
                    if ((LProbMethod == TProbInputValuesSet.pivMean))
                    {
                        if ((GetInputVariables(AConvert, ASoil) > 0.001))
                        {
                            result = LSoilparameterConversion.GetDesignFromMean(AConvert, ASoil, FProbabilisticDefaults);
                        }
                    }
                    else
                    {
                        result = GetInputVariables(AConvert, ASoil);
                    }
                }
            }
            else
            {
                result = GetInputVariables(AConvert, ASoil);
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-07-06       Created
        // =======================================================================================================================
        private double DetermineStresstableFactor(TStabSoilData ASoil)
        {
            double result;
            bool LStandard;
            TProbInputValuesSet LInputType;
            TProbCalculationType LCalculationType;
            bool LUseProbDefaults;
            TConvertTypeSet LConvert;
            TMatStrengthTypeSet LSoilStrengthType;
            result = Constants.CNormValue;
            if ((FModelData.IsProbabilistic))
            {
                LInputType = ASoil.ProbInputValues;
                if ((LInputType == TProbInputValuesSet.pivNone))
                {
                    LInputType = FModelData.DefaultInputValues;
                }
                LUseProbDefaults = ASoil.UseProbDefaults;
                LCalculationType = FCalculationOptions.ProbabilisticCalculationType;
                LSoilStrengthType = ASoil.MaterialStrength;
                if ((new ArrayList(new TMatStrengthTypeSet[]
                    {
                        TMatStrengthTypeSet.mstNone, TMatStrengthTypeSet.Default
                    }).Contains(LSoilStrengthType)))
                {
                    LSoilStrengthType = FModelData.DefaultStrength;
                }
                if ((LSoilStrengthType == TMatStrengthTypeSet.mstStressTab))
                {
                    // ... calculation when only one columns is given ...
                    if (LUseProbDefaults)
                    {
                        LStandard = (LCalculationType == TProbCalculationType.pctDeterministicMean) && (LInputType == TProbInputValuesSet.pivMean);
                        if (!LStandard)
                        {
                            LStandard = (LCalculationType == TProbCalculationType.pctDeterministicDesign) && (LInputType == TProbInputValuesSet.pivDesign);
                        }
                        if (!LStandard)
                        {
                            LStandard = (LCalculationType == TProbCalculationType.pctProbabilistic) && (LInputType == TProbInputValuesSet.pivMean);
                        }
                        // Get the factor for calculation one into the other
                        if (!LStandard)
                        {
                            LConvert = TConvertTypeSet.ctStressTabFactor;
                            result = GetSoilParameterValue(LConvert, ASoil);
                        }
                    }
                }
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================
        private void DetermineMeanFromDesign(ref TStabSoilData ASoil)
        {
            TConvertTypeSet LConvert;
            TMatStrengthTypeSet LMaterialStrength;
            TSoilParameterConversion LSoilparameterConversion;
            LSoilparameterConversion = new TSoilParameterConversion();
            LMaterialStrength = ASoil.MaterialStrength;
            if ((new ArrayList(new TMatStrengthTypeSet[]
                {
                    TMatStrengthTypeSet.mstNone, TMatStrengthTypeSet.Default
                }).Contains(LMaterialStrength)))
            {
                LMaterialStrength = FModelData.DefaultStrength;
            }
            switch (LMaterialStrength)
            {
                case TMatStrengthTypeSet.mstCphi:
                    LConvert = TConvertTypeSet.ctCohesion;
                    ASoil.Cohesion = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctPhi;
                    ASoil.Phi = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstStressTab:
                case TMatStrengthTypeSet.mstPseudoStressTab:
                    ASoil.StresstableFactor = DetermineStresstableFactor(ASoil);
                    break;
                case TMatStrengthTypeSet.mstMeasuredCu:
                    LConvert = TConvertTypeSet.ctCuTop;
                    ASoil.CuTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuBottom;
                    ASoil.CuBottom = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveTop;
                    ASoil.CuPassiveTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveBottom;
                    ASoil.CuPassiveBottom = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveTop;
                    ASoil.CuActiveTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveBottom;
                    ASoil.CuActiveBottom = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstCalculatedCu:
                    LConvert = TConvertTypeSet.ctRatioCuPc;
                    ASoil.RatioCuPc = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRatioCuPcPassive;
                    ASoil.RatioCuPcPassive = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRatioCuPcActive;
                    ASoil.RatioCuPcActive = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveTop;
                    ASoil.CuPassiveTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuPassiveBottom;
                    ASoil.CuPassiveBottom = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveTop;
                    ASoil.CuActiveTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuActiveBottom;
                    ASoil.CuActiveBottom = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctPop;
                    ASoil.POP = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctRRatio;
                    ASoil.RRatio = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    break;
                case TMatStrengthTypeSet.mstGradientCu:
                    LConvert = TConvertTypeSet.ctCuGradientTop;
                    ASoil.CuTop = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    LConvert = TConvertTypeSet.ctCuGradient;
                    ASoil.CuGradient = LSoilparameterConversion.GetMeanFromDesign(LConvert, ASoil, FProbabilisticDefaults);
                    break;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-07-06       Created
        // =======================================================================================================================
        private void AddShortcutsToSoildata()
        {
            int i;
            for (i = FStabSoilData.GetLowerBound(0); i <= FStabSoilData.GetUpperBound(0); i ++)
            {
                StabSoilData[i].ModelData = FModelData;
                StabSoilData[i].CalculationOptions = FCalculationOptions;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-07-06       Created
        // =======================================================================================================================
        private void InitialiseStressTableFactor()
        {
            int i;
            for (i = FStabSoilData.GetLowerBound(0); i <= FStabSoilData.GetUpperBound(0); i ++)
            {
                StabSoilData[i].StresstableFactor = Constants.CNormValue;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================
        private void BackupSoilData()
        {
            int i;
            int LNDim;
            LNDim = FStabSoilData.Length;
            FInitialStabSoilData = new TStabSoilData[LNDim];
            for (i = 0; i < LNDim; i ++)
            {
                FInitialStabSoilData[i] = new TStabSoilData(StabSoilData[i]);
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-07-06       Created
        // =======================================================================================================================
        private void BackupDegreeOfconsolidationData()
        {
            int i;
            int j;
            int LNDim;
            LNDim = FDegreeOfConsolidationSoil.Length;
            FInitialDegreeOfConsolidationSoil = ArraySupport.CreateJaggedArray(LNDim, LNDim);
            for (i = 0; i < LNDim; i ++)
            {
                for (j = 0; j < LNDim; j ++)
                {
                    FInitialDegreeOfConsolidationSoil[i][j] = DegreeOfConsolidationSoil[i][j];
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================

        // =======================================================================================================================
        // Date        ID   Modification
        // 2009-02-11       Created
        // =======================================================================================================================
        private string GetStrengthType(TMatStrengthTypeSet AStrengthType)
        {
            string result;
            TMatStrengthTypeSet LStrengthType;
            result = "";
            LStrengthType = AStrengthType;
            if ((new ArrayList(new TMatStrengthTypeSet[]
                {
                    TMatStrengthTypeSet.mstNone, TMatStrengthTypeSet.Default
                }).Contains(AStrengthType)))
            {
                LStrengthType = FModelData.DefaultStrength;
            }
            switch (LStrengthType)
            {
                case TMatStrengthTypeSet.mstNone:
                    result = "  none         ";
                    break;
                case TMatStrengthTypeSet.mstCphi:
                    result = "  C,Phi        ";
                    break;
                case TMatStrengthTypeSet.mstStressTab:
                    result = "  Stress table ";
                    break;
                case TMatStrengthTypeSet.mstPseudoStressTab:
                    result = "  Pseudo stress table ";
                    break;
                case TMatStrengthTypeSet.mstMeasuredCu:
                    result = "  Measured Cu ";
                    break;
                case TMatStrengthTypeSet.mstCalculatedCu:
                    result = "  Calculated Cu ";
                    break;
                case TMatStrengthTypeSet.mstGradientCu:
                    result = "  Cu gradien ";
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-23       Created
        // =======================================================================================================================
        private string GetDistributionType(TDistributionTypeSet ADistribution)
        {
            string result;
            result = "none";
            switch (ADistribution)
            {
                case TDistributionTypeSet.dsNone:
                    result = "none";
                    break;
                case TDistributionTypeSet.dsUniform:
                    result = "Uniform";
                    break;
                case TDistributionTypeSet.dsNormal:
                    result = "Normal";
                    break;
                case TDistributionTypeSet.dsLogNormal:
                    result = "LogNormal";
                    break;
                case TDistributionTypeSet.dsExponential:
                    result = "Exponential";
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-02-16       Created
        // =======================================================================================================================
        private string LoadTypeString(TLoadTypeSet ALoadType)
        {
            string result;
            result = "";
            switch (ALoadType)
            {
                case TLoadTypeSet.Permanent:
                    result = "Permanent";
                    break;
                case TLoadTypeSet.Temporary:
                    result = "Tijdelijke";
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================
        private string StringInputtype()
        {
            string result;
            result = "";
            switch (FModelData.DefaultInputValues)
            {
                case TProbInputValuesSet.pivNone:
                    result = "none";
                    break;
                case TProbInputValuesSet.pivMean:
                    result = "Mean";
                    break;
                case TProbInputValuesSet.pivDesign:
                    result = "Design";
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-29       Created
        // =======================================================================================================================
        private string StringCalculationType()
        {
            string result;
            result = "";
            switch (FCalculationOptions.ProbabilisticCalculationType)
            {
                case TProbCalculationType.pctDeterministicMean:
                    result = "Deterministisch Mean";
                    break;
                case TProbCalculationType.pctDeterministicDesign:
                    result = "Deterministisch Design";
                    break;
                case TProbCalculationType.pctProbabilistic:
                    result = "Probabilistisch";
                    break;
            }
            return result;
        }

        // Writeln(lft, ' Input type is                :    ', StringInputtype);
        // Writeln(lft, ' Calculation type             :    ', StringCalculationType);
        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-07-06       Created
        // =======================================================================================================================
        private string GetProbInputType(TProbInputValuesSet aprobType)
        {
            string result;
            result = "";
            switch (aprobType)
            {
                case TProbInputValuesSet.pivNone:
                    result = "none";
                    break;
                case TProbInputValuesSet.pivMean:
                    result = "Mean";
                    break;
                case TProbInputValuesSet.pivDesign:
                    result = "Design";
                    break;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-10-09  Best Created
        // =======================================================================================================================
    }

    // end TInterfaceData

    public delegate int TSurfaceFromPointDelegate(double APointX, double APointZ);

    public delegate void TIntersectWaterLinesDelegate();

    public delegate double TIntersectHeadLineDelegate(double AXCoord, int AWaterLineIndex);

    public delegate void TIntersectLayersDelegate();

    public delegate double TIntersectPhreaticLineDelegate(double AXCoord, double AZCoord);

    public delegate double TPorePressureDelegate(double AXCoord, double AZCoord);

    public delegate double TZReferencelevelCuCalculatedDelegate(double AXCoord);

    public delegate double TCenterOfGravityDelegate(double AXCoord, double AZCoord);
}

namespace Deltares.Stability.Calculation.Inner
{
    public class InterfaceData
    {
        // =======================================================================================================================
        // Date        ID   Modification
        // 2009-02-11       Created
        // =======================================================================================================================
        public static string GetBoolAnswer(bool ABool)
        {
            string result;
            if (ABool)
            {
                result = "Yes";
            }
            else
            {
                result = "No";
            }
            return result;
        }
    }

    // end InterfaceData
}