using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.MStab;
using Deltares.Probabilistic;
using Deltares.Stability.Calculation.Inner;
using ShearStrengthModel = Deltares.Geotechnics.Soils.ShearStrengthModel;
using Soil = Deltares.Geotechnics.Soils.Soil;
#if DELPHI
using InterfaceData;
using MStabDataTypes;
using MStabSoilData;
using StressTable;
using ProbabilisticDefaults;
using ProbabilisticTypes;
#else

#endif

namespace Deltares.Stability.Calculation
{
    [Serializable]
    public class SoilException : Exception
    {
        //
        // For guidelines regarding the creation of new exception types, see
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
        // and
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
        //

        public SoilException() {}

        public SoilException(string message)
            : base(message) {}

        public SoilException(string message, Exception inner)
            : base(message, inner) {}

        protected SoilException(
            SerializationInfo info,
            StreamingContext context)
            : base(info, context) {}
    }

    public static partial class LoadObjects
    {
        public static void LoadSoil(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject == null)
            {
                throw new SoilException("Empty aMStabProject");
            }

            //Fill Geometry
            StressTables(aMStabProject, ref aStabilityObjects);
            SoilList(aMStabProject, ref aStabilityObjects);
            ConsolidationSoil(aMStabProject, ref aStabilityObjects);
            FillProbabilisticDefaults(aMStabProject, ref aStabilityObjects);
        }

        private static void StressTables(MStabProject aMStabProject, ref TInterfaceData stabilityObjects)
        {
            if (aMStabProject.SoilModel == null)
            {
                throw new SoilException("Empty SoilModel. Did you load a correct XML file?");
            }

            if (aMStabProject.SoilModel.StressCurves == null)
            {
                throw new SoilException("Empty StressCurves in SoilModel. Did you load a correct XML file?");
            }

            //bond stress curves
            if (aMStabProject.SoilModel.BondStressCurves != null && aMStabProject.SoilModel.BondStressCurves.Count > 0)
            {
                stabilityObjects.BondStresstable = new TStressTable[aMStabProject.SoilModel.BondStressCurves.Count];

                for (int curveIndex = 0; curveIndex < aMStabProject.SoilModel.BondStressCurves.Count; curveIndex++)
                {
                    stabilityObjects.BondStresstable[curveIndex] = new TStressTable();
                    stabilityObjects.BondStresstable[curveIndex].StressTableName =
                        aMStabProject.SoilModel.BondStressCurves[curveIndex].Name;
                    stabilityObjects.BondStresstable[curveIndex].NPoints =
                        aMStabProject.SoilModel.BondStressCurves[curveIndex].BondStresses.Count;

                    for (int pointIndex = 0;
                         pointIndex < aMStabProject.SoilModel.BondStressCurves[curveIndex].BondStresses.Count;
                         pointIndex++)
                    {
                        stabilityObjects.BondStresstable[curveIndex].SetSigma(pointIndex,
                                                                              aMStabProject.SoilModel.BondStressCurves[curveIndex].BondStresses[pointIndex].Sigma);
                        stabilityObjects.BondStresstable[curveIndex].SetTau(pointIndex,
                                                                            aMStabProject.SoilModel.BondStressCurves[curveIndex].BondStresses[pointIndex].Tau);
                    }
                }
            }

            //shear stress curves
            stabilityObjects.Stresstable = new TStressTable[aMStabProject.SoilModel.StressCurves.Count];

            for (int curveIndex = 0; curveIndex < aMStabProject.SoilModel.StressCurves.Count; curveIndex++)
            {
                stabilityObjects.Stresstable[curveIndex] = new TStressTable();
                stabilityObjects.Stresstable[curveIndex].StressTableName = aMStabProject.SoilModel.StressCurves[curveIndex].Description;
                stabilityObjects.Stresstable[curveIndex].NTests = aMStabProject.SoilModel.StressCurves[curveIndex].NumberOfTest;
                stabilityObjects.Stresstable[curveIndex].NPoints = aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus.Count;

                for (int pointIndex = 0; pointIndex < aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus.Count; pointIndex++)
                {
#if DELPHI
                    stabilityObjects.Stresstable[curveIndex].set_Sigma(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].Sigma);
                    stabilityObjects.Stresstable[curveIndex].set_Tau(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].Tau);
                    stabilityObjects.Stresstable[curveIndex].set_TauAvg(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].TauMean);
                    stabilityObjects.Stresstable[curveIndex].set_TauKar(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].TauCharacteristic);
#else
                    stabilityObjects.Stresstable[curveIndex].SetSigma(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].Sigma);
                    stabilityObjects.Stresstable[curveIndex].SetTau(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].Tau);
                    stabilityObjects.Stresstable[curveIndex].SetTauAverage(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].TauMean);
                    stabilityObjects.Stresstable[curveIndex].SetTauKarakteristik(pointIndex, aMStabProject.SoilModel.StressCurves[curveIndex].SigmaTaus[pointIndex].TauCharacteristic);
#endif
                }
            }
        }

        private static int FindCurveIndexByName(string stressCurveName, List<StressCurve> stressCurves)
        {
            var res = -1;
            var index = -1;
            foreach (var stressCurve in stressCurves)
            {
                index++;
                if (stressCurve.Name == stressCurveName)
                {
                    res = index;
                    return res;
                }
            }
            return res;
        }

        private static void SoilList(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject.SoilModel == null)
            {
                throw new SoilException("Empty Soils object in SoilList");
            }

            if (aMStabProject.SoilModel.Soils == null)
            {
                throw new SoilException("Empty Soils object in SoilList");
            }

            aStabilityObjects.StabSoilData = new TStabSoilData[aMStabProject.SoilModel.Soils.Count];

            for (int soilIndex = 0; soilIndex < aMStabProject.SoilModel.Soils.Count; soilIndex++)
            {
                var newSoil = new TStabSoilData();
                Soil oldStabilitySoil = aMStabProject.SoilModel.Soils[soilIndex];
                aStabilityObjects.StabSoilData[soilIndex] = newSoil;

                newSoil.Name = oldStabilitySoil.Description;
                newSoil.GamDry = oldStabilitySoil.AbovePhreaticLevel;
                newSoil.GamWet = oldStabilitySoil.BelowPhreaticLevel;

                if (oldStabilitySoil.UseDefaultShearStrengthInput)
                {
                    newSoil.MaterialStrength = TMatStrengthTypeSet.mstNone;
                }

                switch (oldStabilitySoil.ShearStrengthModel)
                {
                    case ShearStrengthModel.CPhi:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstCphi;
                        break;
                    case ShearStrengthModel.CuCalculated:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstCalculatedCu;
                        break;
                    case ShearStrengthModel.CuGradient:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstGradientCu;
                        break;
                    case ShearStrengthModel.CuMeasured:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstMeasuredCu;
                        break;
                    case ShearStrengthModel.PseudoValues:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstPseudoStressTab;
                        break;
                    case ShearStrengthModel.StressTable:
                        newSoil.MaterialStrength = TMatStrengthTypeSet.mstStressTab;
                        break;
                }

                if (!aMStabProject.Stability.IsReliability)
                {
                    newSoil.ProbInputValues = TProbInputValuesSet.pivNone;
                }
                else
                {
                    switch (oldStabilitySoil.InputModeReliabilityAnalysisOption)
                    {
                        case ReliabilityAnalysisOption.Design:
                            newSoil.ProbInputValues = TProbInputValuesSet.pivDesign;
                            break;
                        case ReliabilityAnalysisOption.Mean:
                            newSoil.ProbInputValues = TProbInputValuesSet.pivMean;
                            break;
                    }
                }

                newSoil.Cohesion = oldStabilitySoil.Cohesion;
                newSoil.Phi = oldStabilitySoil.FrictionAngle;
                newSoil.RatioCuPc = oldStabilitySoil.RatioCuPc;
                newSoil.RatioCuPcPassive = oldStabilitySoil.RatioCuPcPassive;
                newSoil.RatioCuPcActive = oldStabilitySoil.RatioCuPcActive;
                newSoil.POP = oldStabilitySoil.POP;
                newSoil.CuTop = oldStabilitySoil.CuTop;
                newSoil.CuActiveTop = oldStabilitySoil.CuActiveTop;
                newSoil.CuPassiveTop = oldStabilitySoil.CuPassiveTop;
                newSoil.CuBottom = oldStabilitySoil.CuBottom;
                newSoil.CuActiveBottom = oldStabilitySoil.CuActiveBottom;
                newSoil.CuPassiveBottom = oldStabilitySoil.CuPassiveBottom;
                newSoil.CuGradient = oldStabilitySoil.CuGradient;
                newSoil.PorePressureFactor = oldStabilitySoil.PorePressureFactor;
                newSoil.ExcessPorePressure = oldStabilitySoil.ExcessPorePressure;
                newSoil.RestSlope = oldStabilitySoil.RestSlope;

                newSoil.StdCohesion = oldStabilitySoil.CohesionStochast.Deviation;
                newSoil.StdCu = oldStabilitySoil.CuStochast.Deviation;
                newSoil.StdCuGradient = oldStabilitySoil.CuGradientStochast.Deviation;
                newSoil.StdCuTop = oldStabilitySoil.CuTopStochast.Deviation;
                newSoil.StdPn = oldStabilitySoil.PnStochast.Deviation;
                newSoil.StdPhi = oldStabilitySoil.FrictionAngleStochast.Deviation;
                newSoil.StdPOP = oldStabilitySoil.POPStochast.Deviation;
                newSoil.StdRatioCuPc = oldStabilitySoil.RatioCuPcStochast.Deviation;
                newSoil.StdRatioCuPcActive = oldStabilitySoil.RatioCuPcActiveStochast.Deviation;
                newSoil.StdRatioCuPcPassive = oldStabilitySoil.RatioCuPcPassiveStochast.Deviation;
                newSoil.StdRRatio = oldStabilitySoil.RRatioStochast.Deviation;

                newSoil.DistCohesion = ConvertToDistributionType(oldStabilitySoil.CohesionStochast.DistributionType);
                newSoil.DistCu = ConvertToDistributionType(oldStabilitySoil.CuStochast.DistributionType);
                newSoil.DistCuGradient = ConvertToDistributionType(oldStabilitySoil.CuGradientStochast.DistributionType);
                newSoil.DistCuTop = ConvertToDistributionType(oldStabilitySoil.CuTopStochast.DistributionType);
                newSoil.DistPhi = ConvertToDistributionType(oldStabilitySoil.FrictionAngleStochast.DistributionType);
                newSoil.DistPn = ConvertToDistributionType(oldStabilitySoil.PnStochast.DistributionType);
                newSoil.DistPOP = ConvertToDistributionType(oldStabilitySoil.POPStochast.DistributionType);
                newSoil.DistRatioCuPc = ConvertToDistributionType(oldStabilitySoil.RatioCuPcStochast.DistributionType);
                newSoil.DistRatioCuPcActive = ConvertToDistributionType(oldStabilitySoil.RatioCuPcActiveStochast.DistributionType);
                newSoil.DistRatioCuPcPassive = ConvertToDistributionType(oldStabilitySoil.RatioCuPcPassiveStochast.DistributionType);
                newSoil.DistRRatio = ConvertToDistributionType(oldStabilitySoil.RRatioStochast.DistributionType);
                newSoil.DistStressTable = ConvertToDistributionType(oldStabilitySoil.StressTableStochast.DistributionType);
                newSoil.FormReferencePn = oldStabilitySoil.FormReferencePn;
                //implemented soil type conversion
                newSoil.SoilType = ConvertToSoilType(oldStabilitySoil.SoilType);
                newSoil.RRatio = oldStabilitySoil.RRatio;

                newSoil.DesignStdPOP = oldStabilitySoil.POPStochast.DesignDeviation;
                newSoil.DesignStdCohesion = oldStabilitySoil.CohesionStochast.DesignDeviation;
                newSoil.DesignStdPhi = oldStabilitySoil.FrictionAngleStochast.DesignDeviation;
                newSoil.DesignStdCu = oldStabilitySoil.CuStochast.DesignDeviation;
                newSoil.DesignStdRatioCuPc = oldStabilitySoil.RatioCuPcStochast.DesignDeviation;
                newSoil.DesignStdRRatio = oldStabilitySoil.RRatioStochast.DesignDeviation;

                newSoil.DesignPartialPOP = oldStabilitySoil.POPStochast.DesignFactor;
                newSoil.DesignPartialCohesion = oldStabilitySoil.CohesionStochast.DesignFactor;
                newSoil.DesignPartialPhi = oldStabilitySoil.FrictionAngleStochast.DesignFactor;
                newSoil.DesignPartialCu = oldStabilitySoil.CuStochast.DesignFactor;
                newSoil.DesignPartialRatioCuPc = oldStabilitySoil.RatioCuPcStochast.DesignFactor;
                newSoil.DesignPartialRRatio = oldStabilitySoil.RRatioStochast.DesignFactor;

                newSoil.ExcessPorePressure = oldStabilitySoil.ExcessPorePressure;
                newSoil.PorePressureFactor = oldStabilitySoil.PorePressureFactor;
                newSoil.UseProbDefaults = oldStabilitySoil.UseDefaultProbabilisticValues;

                newSoil.SoilGroup = oldStabilitySoil.SoilGroup;

                StressCurve stressCurve = aMStabProject.SoilModel.Soils[soilIndex].StressTable;
                if (stressCurve != null)
                {
                    //                newSoil.StressTable = oldStabilitySoil.StressTable;
                    newSoil.StressTableNr = aMStabProject.SoilModel.StressCurves.IndexOf(stressCurve);
                    if (newSoil.StressTableNr < 0)
                    {
                        newSoil.StressTableNr = FindCurveIndexByName(stressCurve.Name, aMStabProject.SoilModel.StressCurves);
                    }

                    if (newSoil.StressTableNr >= 0)
                    {
                        TStressTable stressTable = aStabilityObjects.Stresstable[newSoil.StressTableNr];
                        newSoil.StressTable = stressTable;
                        newSoil.StressTable.StressTableName = stressCurve.Name;
                        aStabilityObjects.StabSoilData[soilIndex].StressTable = stressTable;
                    }
                }
                BondStressCurve bondStressTable = aMStabProject.SoilModel.Soils[soilIndex].BondStressTable;
                if (bondStressTable != null)
                {
                    newSoil.BondStressTableNr = aMStabProject.SoilModel.BondStressCurves.IndexOf(bondStressTable);
                    if (newSoil.BondStressTableNr >= 0)
                    {
                        newSoil.BondStressTable = aStabilityObjects.BondStresstable[newSoil.BondStressTableNr];
                        newSoil.BondStressTable.StressTableName = bondStressTable.Name;
                        aStabilityObjects.StabSoilData[soilIndex].BondStressTable = aStabilityObjects.BondStresstable[newSoil.BondStressTableNr];
                    }
                }
            }
        }

        private static TSoilTypeSet ConvertToSoilType(SoilType soilType)
        {
            switch (soilType)
            {
                case SoilType.Clay:
                    return TSoilTypeSet.stClay;
                case SoilType.Gravel:
                    return TSoilTypeSet.stGravel;
                case SoilType.Loam:
                    return TSoilTypeSet.stLoam;
                case SoilType.Peat:
                    return TSoilTypeSet.stPeat;
                case SoilType.Sand:
                    return TSoilTypeSet.stSand;
                default:
                    throw new Exception("Cannot convert distribution type: " + soilType.ToString());
            }
        }

        private static TDistributionTypeSet ConvertToDistributionType(DistributionType distribution)
        {
            switch (distribution)
            {
                case DistributionType.Deterministic:
                    return TDistributionTypeSet.dsNone;
                case DistributionType.Normal:
                    return TDistributionTypeSet.dsNormal;
                case DistributionType.Exponential:
                    return TDistributionTypeSet.dsExponential;
                case DistributionType.LogNormal:
                    return TDistributionTypeSet.dsLogNormal;
                case DistributionType.Uniform:
                    return TDistributionTypeSet.dsUniform;
                default:
                    throw new Exception("Cannot convert distribution type: " + distribution.ToString());
            }
        }

        private static void ConsolidationSoil(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            aStabilityObjects.DegreeOfConsolidationSoil = new double[aMStabProject.Stability.SoilProfile.Surfaces.Count][];
            for (int surfaceRowIndex = 0; surfaceRowIndex < aMStabProject.Stability.SoilProfile.Surfaces.Count; surfaceRowIndex++)
            {
                aStabilityObjects.DegreeOfConsolidationSoil[surfaceRowIndex] = new double[aMStabProject.Stability.SoilProfile.Surfaces.Count];

                for (int surfaceColumnIndex = 0; surfaceColumnIndex < aMStabProject.Stability.SoilProfile.Surfaces.Count; surfaceColumnIndex++)
                {
                    aStabilityObjects.DegreeOfConsolidationSoil[surfaceRowIndex][surfaceColumnIndex] = aMStabProject.Stability.ConsolidationMatrix.GetConsolidation(aMStabProject.Stability.SoilProfile.Surfaces[surfaceRowIndex], aMStabProject.Stability.SoilProfile.Surfaces[surfaceColumnIndex]);
                    //aStabilityObjects.DegreeOfConsolidationSoil[surfaceRowIndex][surfaceColumnIndex] = aMStabProject.Stability.DegreeofConsolidationSoilSurface.DegreeOfConsolidationArray[surfaceRowIndex, surfaceColumnIndex];
                }
            }
        }

        private static void FillProbabilisticDefaults(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            var newDefaults = new TProbabilisticDefaults();
            aStabilityObjects.ProbabilisticDefaults = newDefaults;
            ProbabilisticDefaults oldDefaults = aMStabProject.Stability.ProbabilisticDefaults;

            newDefaults.CohesionDesignPartial = oldDefaults.CohesionStochast.DesignFactor;
            newDefaults.CohesionDesignStdDev = oldDefaults.CohesionStochast.DesignDeviation;
            newDefaults.CohesionDistribution = ConvertToDistributionType(oldDefaults.CohesionStochast.DistributionType);
            newDefaults.CohesionVariationTotal = oldDefaults.CohesionStochast.Variation;

            newDefaults.CompressionRatioDesignPartial = oldDefaults.CompressionStochast.DesignFactor;
            newDefaults.CompressionRatioDesignStdDev = oldDefaults.CompressionStochast.DesignDeviation;
            newDefaults.CompressionRatioDistribution = ConvertToDistributionType(oldDefaults.CompressionStochast.DistributionType);
            newDefaults.CompressionRatioVariationTotal = oldDefaults.CompressionStochast.Variation;

            newDefaults.ConsolidationCoefDesignPartial = oldDefaults.ConsolidationStochast.DesignFactor;
            newDefaults.ConsolidationCoefDesignStdDev = oldDefaults.ConsolidationStochast.DesignDeviation;
            newDefaults.ConsolidationCoefDistribution = ConvertToDistributionType(oldDefaults.ConsolidationStochast.DistributionType);
            newDefaults.ConsolidationCoefTotalStdDev = oldDefaults.ConsolidationStochast.Deviation;

            newDefaults.CuDesignPartial = oldDefaults.CuStochast.DesignFactor;
            newDefaults.CuDesignStdDev = oldDefaults.CuStochast.DesignDeviation;
            newDefaults.CuDistribution = ConvertToDistributionType(oldDefaults.CuStochast.DistributionType);
            newDefaults.CuVariationTotal = oldDefaults.CuStochast.Variation;

            newDefaults.LimitValueBishopDistribution = ConvertToDistributionType(oldDefaults.LimitValueBishopStochast.DistributionType);
            newDefaults.LimitValueBishopMean = oldDefaults.LimitValueBishopStochast.Mean;
            newDefaults.LimitValueBishopStdDev = oldDefaults.LimitValueBishopStochast.Deviation;

            newDefaults.LimitValueVanDistribution = ConvertToDistributionType(oldDefaults.LimitValueVanStochast.DistributionType);
            newDefaults.LimitValueVanMean = oldDefaults.LimitValueVanStochast.Mean;
            newDefaults.LimitValueVanStdDev = oldDefaults.LimitValueVanStochast.Deviation;

            newDefaults.HydraulicPressureDesignPartial = oldDefaults.HydraulicPressureStochast.DesignFactor;
            newDefaults.HydraulicPressureDesignStdDev = oldDefaults.HydraulicPressureStochast.DesignDeviation;
            newDefaults.HydraulicPressureDistribution = ConvertToDistributionType(oldDefaults.HydraulicPressureStochast.DistributionType);
            newDefaults.HydraulicPressureTotalStdDev = oldDefaults.HydraulicPressureStochast.Deviation;

            newDefaults.PhiDesignPartial = oldDefaults.FrictionAngleStochast.DesignFactor;
            newDefaults.PhiDesignStdDev = oldDefaults.FrictionAngleStochast.DesignDeviation;
            newDefaults.PhiDistribution = ConvertToDistributionType(oldDefaults.FrictionAngleStochast.DistributionType);
            newDefaults.PhiVariationTotal = oldDefaults.FrictionAngleStochast.Variation;

            newDefaults.POPDesignPartial = oldDefaults.POPStochast.DesignFactor;
            newDefaults.POPDesignStdDev = oldDefaults.POPStochast.DesignDeviation;
            newDefaults.POPDistribution = ConvertToDistributionType(oldDefaults.POPStochast.DistributionType);
            newDefaults.POPVariationTotal = oldDefaults.POPStochast.Variation;

            newDefaults.RatioCuPcDesignPartial = oldDefaults.RatioCuPcStochast.DesignFactor;
            newDefaults.RatioCuPcDesignStdDev = oldDefaults.RatioCuPcStochast.DesignDeviation;
            newDefaults.RatioCuPcDistribution = ConvertToDistributionType(oldDefaults.RatioCuPcStochast.DistributionType);
            newDefaults.RatioCuPcVariationTotal = oldDefaults.RatioCuPcStochast.Variation;

            newDefaults.StressTableDesignPartial = oldDefaults.StressTableStochast.DesignFactor;
            newDefaults.StressTableDesignStdDev = oldDefaults.StressTableStochast.DesignDeviation;
            newDefaults.StressTableDistribution = ConvertToDistributionType(oldDefaults.StressTableStochast.DistributionType);
            newDefaults.StressTableVariationTotal = oldDefaults.StressTableStochast.Variation;
        }
    }
}