using System;
using System.Runtime.Serialization;
using Deltares.MStab;
using Deltares.Stability.Calculation.Inner;
#if DELPHI
using InterfaceData;
using LineLoad;
using MStabDataTypes;
using UniformLoad;
#else

#endif

namespace Deltares.Stability.Calculation
{
    [Serializable]
    public class LoadsException : 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 LoadsException() {}

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

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

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

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

            //Fill Loads
            TreeOnSlope(aMStabProject, ref aStabilityObjects);
            UniformLoads(aMStabProject, ref aStabilityObjects);
            LineLoads(aMStabProject, ref aStabilityObjects);
            Nails(aMStabProject, ref aStabilityObjects);
            EarthQuakeFactors(aMStabProject, ref aStabilityObjects);
            ConsolidationLoads(aMStabProject, ref aStabilityObjects);
            ConsolidationEarthQuake(aMStabProject, ref aStabilityObjects);
        }

        private static void TreeOnSlope(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject.Stability == null)
            {
                throw new LoadsException("Empty Loads in Tree on slope");
            }

            if (aMStabProject.Stability.TreeOnSlope == null)
            {
                return;
                //throw new LoadsException("Empty  Loads in Tree on slope ");
            }

            aStabilityObjects.TreeOnSlope = new TTreeOnSlope();
            aStabilityObjects.TreeOnSlope.AngleOfDistribution = aMStabProject.Stability.TreeOnSlope.AngleOfDistribution;
            aStabilityObjects.TreeOnSlope.WindForce = aMStabProject.Stability.TreeOnSlope.WindForce;
            aStabilityObjects.TreeOnSlope.XCoordinate = aMStabProject.Stability.TreeOnSlope.X;
            aStabilityObjects.TreeOnSlope.ZCoordinate = aMStabProject.Stability.TreeOnSlope.Z;
            aStabilityObjects.TreeOnSlope.WidthOfRootZone = aMStabProject.Stability.TreeOnSlope.WidthOfRootZone;
            if (Math.Abs(aStabilityObjects.TreeOnSlope.WindForce) > MStabDataConstants.CAccuracy)
            {
                aStabilityObjects.TreeOnSlope.SurfaceLine = aStabilityObjects.SurfaceLine;
                aStabilityObjects.TreeOnSlope.CreateLoads();
                aStabilityObjects.TreeOnSlope.IsUsed = true;
            }
        }

        private static void UniformLoads(MStabProject aMStabProject, ref TInterfaceData stabilityObjects)
        {
            int Extra = 0;
            int LoadNumber;
            if (stabilityObjects.TreeOnSlope != null && stabilityObjects.TreeOnSlope.IsUsed)
            {
                Extra = 2;
            }
            if (aMStabProject.Stability == null)
            {
                throw new LoadsException("Empty Loads in UniformLoad");
            }

            if (aMStabProject.Stability.UniformLoads == null)
            {
                throw new LoadsException("Empty UniformLoads in Loads in UniformLoad");
            }

            stabilityObjects.UniformLoad = new TUniformLoad[aMStabProject.Stability.UniformLoads.Count + Extra];

            for (int load = 0; load < aMStabProject.Stability.UniformLoads.Count; load++)
            {
                stabilityObjects.UniformLoad[load] = new TUniformLoad();
                stabilityObjects.UniformLoad[load].UniformLoadName = aMStabProject.Stability.UniformLoads[load].Name;
                stabilityObjects.UniformLoad[load].LoadType = (TLoadTypeSet) aMStabProject.Stability.UniformLoads[load].LoadType;
                stabilityObjects.UniformLoad[load].DistributionAngle = aMStabProject.Stability.UniformLoads[load].DistributionAngle;
                stabilityObjects.UniformLoad[load].Magnitude = aMStabProject.Stability.UniformLoads[load].Magnitude;
                stabilityObjects.UniformLoad[load].Xstart = aMStabProject.Stability.UniformLoads[load].XStart;
                stabilityObjects.UniformLoad[load].Xend = aMStabProject.Stability.UniformLoads[load].XEnd;
            }
            if (Extra > 0)
            {
                // Uniform loads from tree on slope added
                LoadNumber = aMStabProject.Stability.UniformLoads.Count;
                stabilityObjects.UniformLoad[LoadNumber] = new TUniformLoad();
                stabilityObjects.UniformLoad[LoadNumber] = stabilityObjects.TreeOnSlope.UniformLoading;

                LoadNumber = aMStabProject.Stability.UniformLoads.Count + 1;
                stabilityObjects.UniformLoad[LoadNumber] = new TUniformLoad();
                stabilityObjects.UniformLoad[LoadNumber] = stabilityObjects.TreeOnSlope.UniformUnLoading;
            }
        }

        private static void LineLoads(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            int Extra = 0;
            int LoadNumber;
            if (aStabilityObjects.TreeOnSlope != null && aStabilityObjects.TreeOnSlope.IsUsed)
            {
                Extra = 1;
            }

            if (aMStabProject.Stability == null)
            {
                throw new LoadsException("Empty Loads in LineLoads");
            }

            if (aMStabProject.Stability.LineLoads == null)
            {
                throw new LoadsException("Empty LineLoads in Loads in LineLoads");
            }

            aStabilityObjects.LineLoad = new TLineLoad[aMStabProject.Stability.LineLoads.Count + Extra];

            for (int load = 0; load < aMStabProject.Stability.LineLoads.Count; load++)
            {
                aStabilityObjects.LineLoad[load] = new TLineLoad();
                aStabilityObjects.LineLoad[load].LineLoadName = aMStabProject.Stability.LineLoads[load].Name;
                aStabilityObjects.LineLoad[load].DirectionAngle = aMStabProject.Stability.LineLoads[load].Direction;
                aStabilityObjects.LineLoad[load].DistributionAngle = aMStabProject.Stability.LineLoads[load].Distribution;
                aStabilityObjects.LineLoad[load].Magnitude = aMStabProject.Stability.LineLoads[load].Magnitude;
                aStabilityObjects.LineLoad[load].X = aMStabProject.Stability.LineLoads[load].X;
                aStabilityObjects.LineLoad[load].Z = aMStabProject.Stability.LineLoads[load].Z;
            }
            if (Extra > 0)
            {
                // Aditional line load from tree on slope
                LoadNumber = aMStabProject.Stability.LineLoads.Count;
                aStabilityObjects.LineLoad[LoadNumber] = new TLineLoad();
                aStabilityObjects.LineLoad[LoadNumber] = aStabilityObjects.TreeOnSlope.LineLoad;
            }
        }

        private static void Nails(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject.Stability == null)
            {
                throw new LoadsException("Empty Loads in Nails");
            }

            if (aMStabProject.Stability.Nails == null)
            {
                throw new LoadsException("Empty Nails in Loads in Nails");
            }

            aStabilityObjects.Nail = new TNail[aMStabProject.Stability.Nails.Count];

            for (int nail = 0; nail < aMStabProject.Stability.Nails.Count; nail++)
            {
                aStabilityObjects.Nail[nail] = new TNail(aStabilityObjects);
                aStabilityObjects.Nail[nail].NailName = aMStabProject.Stability.Nails[nail].Name;
                //classic has counterclockwise direction and starts on east direction
                //DSL nail has clockwise direction and starts on south direction
                aStabilityObjects.Nail[nail].DirectionAngle = (-aMStabProject.Stability.Nails[nail].Direction) - 90;
                aStabilityObjects.Nail[nail].HorizontalSpacing = aMStabProject.Stability.Nails[nail].HorizontalSpacing;
                aStabilityObjects.Nail[nail].Length = aMStabProject.Stability.Nails[nail].Length;

                aStabilityObjects.Nail[nail].CriticalAngle = aMStabProject.Stability.Nails[nail].CriticalAngle;
                //aStabilityObjects.Nail[nail].TaumaxType = aMStabProject.Stability.Nails[nail].TaumaxType;

                aStabilityObjects.Nail[nail].DiameterNail = aMStabProject.Stability.Nails[nail].DiameterNail;
                aStabilityObjects.Nail[nail].DiameterGrout = aMStabProject.Stability.Nails[nail].DiameterGrout;
                aStabilityObjects.Nail[nail].YieldForce = aMStabProject.Stability.Nails[nail].YieldForce;
                aStabilityObjects.Nail[nail].PlasticMoment = aMStabProject.Stability.Nails[nail].PlasticMoment;
                aStabilityObjects.Nail[nail].BendingStiffness = aMStabProject.Stability.Nails[nail].BendingStiffness;
                aStabilityObjects.Nail[nail].IsFacingUsed = aMStabProject.Stability.Nails[nail].UseFacing;
                aStabilityObjects.Nail[nail].X = aMStabProject.Stability.Nails[nail].X;
                aStabilityObjects.Nail[nail].Y = aMStabProject.Stability.Nails[nail].Z;
                aStabilityObjects.Nail[nail].UseShearstressTable = aMStabProject.Stability.Nails[nail].UseShearStress;
                aStabilityObjects.Nail[nail].UseLateralStressTable =
                    aMStabProject.Stability.Nails[nail].UseLateralStress;
                aStabilityObjects.Nail[nail].MaxPullForce = aMStabProject.Stability.Nails[nail].MaxPullForce;
                aStabilityObjects.Nail[nail].MaxMom = aMStabProject.Stability.Nails[nail].MaxMom;
                aStabilityObjects.Nail[nail].EI = aMStabProject.Stability.Nails[nail].EI;

                aStabilityObjects.Nail[nail].ShearStressTable = new TShearStressTable();
                for (int pointIndex = 0;
                     pointIndex < aMStabProject.Stability.Nails[nail].ShearStressCurve.ShearStresses.Count;
                     pointIndex++)
                {
                    aStabilityObjects.Nail[nail].ShearStressTable.NPoints =
                        aMStabProject.Stability.Nails[nail].ShearStressCurve.ShearStresses.Count;

                    aStabilityObjects.Nail[nail].ShearStressTable.SetSigma(pointIndex,
                                                                           aMStabProject.Stability.Nails[nail].ShearStressCurve.ShearStresses[pointIndex].Sigma);
                    aStabilityObjects.Nail[nail].ShearStressTable.SetDistance(pointIndex,
                                                                              aMStabProject.Stability.Nails[nail].ShearStressCurve.ShearStresses[pointIndex].Distance);
                }
                aStabilityObjects.Nail[nail].LateralStressCurves = new TLateralStressTable();
                for (int pointIndex = 0;
                     pointIndex < aMStabProject.Stability.Nails[nail].LateralStressCurve.ShearStresses.Count;
                     pointIndex++)
                {
                    aStabilityObjects.Nail[nail].LateralStressCurves.NPoints =
                        aMStabProject.Stability.Nails[nail].LateralStressCurve.ShearStresses.Count;

                    aStabilityObjects.Nail[nail].LateralStressCurves.SetSigma(pointIndex,
                                                                              aMStabProject.Stability.Nails[nail].LateralStressCurve.ShearStresses[pointIndex].Sigma);
                    aStabilityObjects.Nail[nail].LateralStressCurves.SetDistance(pointIndex,
                                                                                 aMStabProject.Stability.Nails[nail].LateralStressCurve.ShearStresses[pointIndex].Distance);
                }
            }
        }

        private static void EarthQuakeFactors(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject.Stability == null)
            {
                throw new LoadsException("Empty Loads in EarthQuakeFactors");
            }

            if (aMStabProject.Stability.Earthquake == null)
            {
                return;
            }
            aStabilityObjects.SetEarthQuakeFactors(aMStabProject.Stability.Earthquake.FreeWaterFact, aMStabProject.Stability.Earthquake.HorQuakeFact, aMStabProject.Stability.Earthquake.VerQuakeFact);
        }

        private static void ConsolidationLoads(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            //if (aMStabProject.Stability.DegreeofConsolidationUniformLoad.DegreeOfConsolidationArray.Length > 0)
            //{
            aStabilityObjects.DegreeOfConsolidationLoads = new double[aMStabProject.Stability.SoilProfile.Surfaces.Count];
            for (int loadIndex = aMStabProject.Stability.SoilProfile.Surfaces.Count - 1; loadIndex >= 0; loadIndex--)
            {
                aStabilityObjects.DegreeOfConsolidationLoads[loadIndex] = aMStabProject.Stability.ConsolidationMatrix.GetConsolidation(aMStabProject.Stability.ConsolidationLoad, aMStabProject.Stability.SoilProfile.Surfaces[loadIndex]);
                //aStabilityObjects.DegreeOfConsolidationLoads[loadIndex] = 100;
            }
            //}
        }

        private static void ConsolidationEarthQuake(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            //if (aMStabProject.Stability.DegreeofConsolidationEarthquake.DegreeOfConsolidationArray.Length > 0)
            //{
            TEarthquakeData earthquake = aStabilityObjects.GetEarthQuake();
            earthquake.DegreeOfConsolidation = new double[aMStabProject.Stability.SoilProfile.Surfaces.Count];
            for (int surfaceIndex = 0; surfaceIndex < aMStabProject.Stability.SoilProfile.Surfaces.Count; surfaceIndex++)
            {
                earthquake.DegreeOfConsolidation[surfaceIndex] = aMStabProject.Stability.ConsolidationMatrix.GetConsolidation(aMStabProject.Stability.Earthquake, aMStabProject.Stability.SoilProfile.Surfaces[surfaceIndex]);
            }
            aStabilityObjects.SetEarthQuake(earthquake);
            //}
        }
    }
}