using System;
using System.Collections;
using System.Collections.Generic;

// =======================================================================================================================
// Class name:
//
// Description:  Base clase for all slip planes (circulair and non circulair
//
// Copyright (c) 1996-2010 Deltares
//
// Date        ID   Modification
// 2008-03-27  Best Created
// 2008-04-24  Best FillSlices added
// 2008-08-14  Best FDumpData added
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    public class TSlipPlane
    {
        // properties
        protected int[][] FAanpasArr;
        protected double FBeta = 0;
        protected string FCalculationNote = String.Empty;
        protected double[][] FCovariantie;
        protected bool FDoDumpData = false;
        protected double[][] FEivec;
        protected double[] FEx;
        protected double FGamWat = 0;
        protected int FIerr = 0;
        protected TInterfaceData FInterfaceData = null;
        // Aantal correlaties (1 indien geen correlaties
        protected bool FIsDars = false;
        protected bool FIsForm = false;
        protected bool FIsMonteCarlo = false;
        protected int FIter = 0;
        protected int FLeftNumber = 0;
        protected int FNSlices = 0;
        protected int FNStochastic = 0;
        protected int FNumCor = 0;
        protected int FNumEivec = 0;
        protected string[] FParamName;
        protected TProbCalculation FProbCalculation = null;
        protected int FRightNumber = 0;
        protected TSliceDivision FSliceDivision = null;
        protected Tslice[] FSlices;
        protected List<TStabSoilData> FSoilData = new List<TStabSoilData>();
        protected TMStabProbabilisticData FStabProbabilisticData = null;
        protected double FStuurpar = 0;
        protected double[] FSx;
        protected string FTestFileName = String.Empty;
        protected double[] FU;
        protected int[][] FVarArr;
        protected int[] FVerdeling;
        protected double[][] FVp;
        protected bool FWithCorrelation = false;
        //      protected double FSafety = 0;
        // tijdelijke veiligheid

        // linker snijpunt met het oppervlak
        protected double FXRightSurface = 0;
        // rechtersnijpunt met het oppervlak
        protected double FZLeftSurface = 0;
        // linker snijpunt met het oppervlak
        protected double FZRightSurface = 0;
        protected double[] FZes = new double[3];
        protected int FZoneNr;
        protected double[] Fx;
        protected double FxLeftSurface = 0;
        // rechtersnijpunt met het oppervlak
        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-03-27  Best Created
        // =======================================================================================================================
        //Constructor  Create()
        public TSlipPlane() : base()
        {
            FDoDumpData = false;
            // TODO: Add any constructor code here
        }

        public bool DoDumpData
        {
            get
            {
                return FDoDumpData;
            }
            set
            {
                FDoDumpData = value;
            }
        }

        public TInterfaceData InterfaceData
        {
            get
            {
                return FInterfaceData;
            }
            set
            {
                FInterfaceData = value;
            }
        }

        public double GamWat
        {
            get
            {
                return FGamWat;
            }
            set
            {
                FGamWat = value;
            }
        }

        public double XLeftSurface
        {
            get
            {
                return FxLeftSurface;
            }
            set
            {
                FxLeftSurface = value;
            }
        }

        public double XRightSurface
        {
            get
            {
                return FXRightSurface;
            }
            set
            {
                FXRightSurface = value;
            }
        }

        public double ZLeftSurface
        {
            get
            {
                return FZLeftSurface;
            }
            set
            {
                FZLeftSurface = value;
            }
        }

        public double ZRightSurface
        {
            get
            {
                return FZRightSurface;
            }
            set
            {
                FZRightSurface = value;
            }
        }

        public int NSlices
        {
            get
            {
                return GetSliceCount();
            }
        }

        public string CalculationNote
        {
            get
            {
                return FCalculationNote;
            }
            set
            {
                FCalculationNote = value;
            }
        }

        public TprobabilisticData ProbabilisticResutData
        {
            get
            {
                return GetprobabilisticResultdata();
            }
        }

        public int ZoneNr
        {
            get
            {
                return FZoneNr;
            }
            set
            {
                FZoneNr = value;
            }
        }

        public virtual void CreateSlices()
        {
            FSliceDivision = new TSliceDivision();
            FSliceDivision.CalculationType = FInterfaceData.ModelData.CalcType;
            FSliceDivision.LeftSideIsActive = FInterfaceData.ModelData.LeftSideIsActive;
            FSliceDivision.StriveSlice = Math.Max(1, FInterfaceData.CalculationOptions.StriveSlice);
            FSliceDivision.XLeftSurface = FxLeftSurface;
            FSliceDivision.XRightSurface = FXRightSurface;
            FSliceDivision.SurfaceLine = FInterfaceData.SurfaceLine;
            FSliceDivision.GeometryPoints = FInterfaceData.GeometryPoints;
            FSliceDivision.Layers = FInterfaceData.Layers;
            FSliceDivision.WaterLines = FInterfaceData.CurrentWaternet.Waterlines;
            FSliceDivision.PLLines = FInterfaceData.CurrentWaternet.PLLines;
            if (FInterfaceData.CurrentWaternet.PhreaticLineNumber >= 0)
            {
                FSliceDivision.FreaticLine = FInterfaceData.CurrentWaternet.PLLines[FInterfaceData.CurrentWaternet.PhreaticLineNumber];
            }
            else
            {
                FSliceDivision.FreaticLine = null;
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-03-31  Best Created
        // =======================================================================================================================

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-05-25       Created
        // =======================================================================================================================
        public virtual double GetReliabilityIndex()
        {
            double result;
            result = -1;
            // Initialisation
            FVerdeling = null;
            FEx = null;
            FSx = null;
            FVp = null;
            FParamName = null;
            FCovariantie = null;
            FEivec = null;
            Fx = null;
            FU = null;
            FIsMonteCarlo = false;
            FIsDars = false;
            FIsForm = true;
            FWithCorrelation = false;
            FStuurpar = 0.5;
            FBeta = -1;
            FIter = 150;
            FGamWat = FInterfaceData.CurrentWaternet.GammaWater;
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-24  Best Created
        // =======================================================================================================================

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-03-27  Best Created
        // =======================================================================================================================
        public void SetSlice(int AIndex, Tslice ASlice)
        {
            if ((ASlice != null))
            {
                if ((AIndex >= 0))
                {
                    if (((AIndex + 1) >= FSlices.Length))
                    {
                        FSlices = new Tslice[AIndex + 1];
                    }
                    FSlices[AIndex] = ASlice;
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-03-27  Best Created
        // =======================================================================================================================
        public Tslice GetSlice(int AIndex)
        {
            Tslice result;
            result = null;
            if ((AIndex >= 0) && (AIndex < FSlices.Length))
            {
                if (FSlices[AIndex] != null)
                {
                    result = FSlices[AIndex];
                }
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-03-31  Best Created
        // =======================================================================================================================
        public void AddSlices(Tslice aSlice)
        {
            FNSlices = FSlices.Length;
            FNSlices ++;
            FSlices = new Tslice[FNSlices];
            FSlices[FNSlices - 1] = new Tslice(aSlice);
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-24  Best Created
        // =======================================================================================================================
        public void swapslices(int first, int second)
        {
            Tslice aSlice;
            aSlice = FSlices[first];
            FSlices[first] = FSlices[second];
            FSlices[second] = aSlice;
        }

        public double[] GetSliceArray()
        {
            double[] result;
            double[] LSliceData;
            int i;
            LSliceData = new double[(FNSlices + 1)*2];
            if (FNSlices > 0)
            {
                for (i = 0; i < FNSlices; i ++)
                {
                    LSliceData[2*i] = FSlices[i].xLeft;
                    LSliceData[2*i + 1] = FSlices[i].ZBottomLeft;
                }
                LSliceData[2*FNSlices] = FSlices[FNSlices - 1].xRight;
                LSliceData[2*FNSlices + 1] = FSlices[FNSlices - 1].ZBottomRight;
            }
            result = LSliceData;
            return result;
        }

        protected TprobabilisticData GetprobabilisticResultdata()
        {
            TprobabilisticData result;

            //if ((FStabProbabilisticData != null))
            //{
            FStabProbabilisticData.ProbabilisticResultDump(FBeta);
            result = FStabProbabilisticData.probabilisticData;
            //}

            return result;
        }

        protected int GetSliceCount()
        {
            int result;
            result = FSlices.Length;
            return result;
        }

        protected double SMobilised(double ALength, double ARedZone)
        {
            double result;
            // Minimum lenght=0, always 100% mobilisation
            if ((Math.Abs(ARedZone) < 0.001))
            {
                result = 1;
            }
            else
            {
                result = Math.Min(ALength, ARedZone)/ARedZone;
            }
            return result;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-24  Best Created
        // =======================================================================================================================
        protected virtual void RemoveLocalPointers()
        {
            FNSlices = FSlices.Length;
            FNSlices = 0;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-24  Best Created
        // =======================================================================================================================
        protected void FillSlices()
        {
            TSliceFill LSliceFill;
            LSliceFill = new TSliceFill();
            // try
            LSliceFill.SoilData = FInterfaceData.StabSoilData;
            if (FInterfaceData.CurrentWaternet.PhreaticLineNumber >= 0)
            {
                LSliceFill.FreaticLine = FInterfaceData.CurrentWaternet.PLLines[FInterfaceData.CurrentWaternet.PhreaticLineNumber];
            }
            LSliceFill.SurfaceLine = FInterfaceData.SurfaceLine;
            LSliceFill.PLLines = FInterfaceData.CurrentWaternet.PLLines;
            LSliceFill.WaterLines = FInterfaceData.CurrentWaternet.Waterlines;
            LSliceFill.GammaWater = FInterfaceData.CurrentWaternet.GammaWater;

            LSliceFill.DefaultStrength = FInterfaceData.ModelData.DefaultStrength;
            LSliceFill.ProbabilisticCalculationType = FInterfaceData.CalculationOptions.ProbabilisticCalculationType;
            LSliceFill.IsUpliftCalculation = (new ArrayList(new TCalculationTypeSet[]
                {
                    TCalculationTypeSet.csLift, TCalculationTypeSet.csLiftSpencer
                }).Contains(FInterfaceData.ModelData.CalcType));
            LSliceFill.IsProbabilisticCalculation = FInterfaceData.ModelData.IsProbabilistic;
            LSliceFill.IsAlternativeStrengthUsed = FInterfaceData.ModelData.HasAlternativeStrength;
            LSliceFill.IsMSeepNetUsed = FInterfaceData.CalculationOptions.IsMSeepUsed;
            LSliceFill.MSeepfilename = FInterfaceData.CalculationOptions.MSeepFileName;
            LSliceFill.EarthquakeData = FInterfaceData.Earthquake;
            LSliceFill.UniformLoad = FInterfaceData.UniformLoad;
            LSliceFill.LineLoad = FInterfaceData.LineLoad;
            LSliceFill.IsGlobalMesurement = FInterfaceData.ModelData.HasGlobalMeasurements;
            LSliceFill.LeftNumber = FLeftNumber;
            LSliceFill.RightNumber = FRightNumber;
            LSliceFill.DegreeOfConsolidationLoads = FInterfaceData.DegreeOfConsolidationLoads;
            LSliceFill.DegreeOfConsolidationSoil = FInterfaceData.DegreeOfConsolidationSoil;
            LSliceFill.StressTable = FInterfaceData.Stresstable;
            LSliceFill.InterfaceCalls = FInterfaceData.InterfaceCalls;
            if (FInterfaceData.ModelData.LeftSideIsActive)
            {
                LSliceFill.StabilitySide = TStabilitySideSet.RightSide;
            }
            else
            {
                LSliceFill.StabilitySide = TStabilitySideSet.LeftSide;
            }
            LSliceFill.FillSlices(FNSlices, ref FSlices);
            // (*  finally
            // LSliceFill.Free;
            // end;
            // *)
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-03-31  Bkm  Created
        // =======================================================================================================================
    }

    // end TSlipPlane
}

namespace Deltares.Stability.Calculation.Inner
{
    public class SlipPlane
    {
        public const double CGeoAccuracy = 0.001;
        public static void probabilisticcalculation() {}
    }

    // end SlipPlane
}