using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.MStab;
using Deltares.MStab.IO.Classic;
using Deltares.Stability.Calculation.Inner;
#if DELPHI
using ForbiddenLine;
using InterfaceData;
using MStabDataTypes;
#else

#endif

namespace Deltares.Stability.Calculation
{
    public static partial class LoadObjects
    {
        public static void LoadDefinitions(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            if (aMStabProject == null)
            {
                throw new GeometryException("Empty aMStabProject");
            }

            //Fill Definitions            
            ForbiddenLines(aMStabProject, ref aStabilityObjects);
            CenterPointData(aMStabProject, ref aStabilityObjects);
            ZoneAreas(aMStabProject, ref aStabilityObjects);
        }

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

            if (aMStabProject.Stability.ForbiddenLinesList == null)
            {
                throw new DefinitionException("Empty ForbiddenLines in Definition in ForbiddenLines");
            }

            aStabilityObjects.ForbiddenLines = new TForbiddenLine[aMStabProject.Stability.ForbiddenLinesList.Count];

            for (int forbiddenline = 0; forbiddenline < aMStabProject.Stability.ForbiddenLinesList.Count; forbiddenline++)
            {
                aStabilityObjects.ForbiddenLines[forbiddenline] = new TForbiddenLine();
                aStabilityObjects.ForbiddenLines[forbiddenline].ForbiddenLineName = aMStabProject.Stability.ForbiddenLinesList[forbiddenline].Name;

                aStabilityObjects.ForbiddenLines[forbiddenline].Addpoint(aMStabProject.Stability.ForbiddenLinesList[forbiddenline].StartPoint.X,
                                                                         aMStabProject.Stability.ForbiddenLinesList[forbiddenline].StartPoint.Z);

                aStabilityObjects.ForbiddenLines[forbiddenline].Addpoint(aMStabProject.Stability.ForbiddenLinesList[forbiddenline].EndPoint.X,
                                                                         aMStabProject.Stability.ForbiddenLinesList[forbiddenline].EndPoint.Z);
            }
        }

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

            SlipCircle slipCircle = aMStabProject.Stability.SlipCircle;
            if (slipCircle == null)
            {
                return;
            }

            TSlipCircleData slipCircleData = aStabilityObjects.GetSlipCircleData();
            if ((aMStabProject.Stability.ModelOption == ModelOptions.Bishop) ||
                (aMStabProject.Stability.ModelOption == ModelOptions.BishopProbabilityRandomField) ||
                (aMStabProject.Stability.ModelOption == ModelOptions.Fellenius))
            {
                slipCircleData.XFixed = slipCircle.SlipCircleFixedPoint.XFixed;
                slipCircleData.Zfixed = slipCircle.SlipCircleFixedPoint.ZFixed;
                slipCircleData.UseFixedpoint = slipCircle.SlipCircleFixedPoint.UseFixedPoint;
                slipCircleData.TopTangentZ = slipCircle.SlipCircleTangentLine.TangentLineZTop;
                slipCircleData.BottomTangentZ = slipCircle.SlipCircleTangentLine.TangentLineZBottom;

                slipCircleData.TangentIntervalCount = slipCircle.SlipCircleTangentLine.TangentLineNumber - 1;
                slipCircleData.XLeftCenterPoint = slipCircle.SlipCircleGrid.GridXLeft;

                slipCircleData.XIntervalCount = slipCircle.SlipCircleGrid.XIntervalNumber;
                slipCircleData.XRightCenterPoint = slipCircle.SlipCircleGrid.GridXRight;
                slipCircleData.ZBottomCenterPoint = slipCircle.SlipCircleGrid.GridZBottom;

                slipCircleData.ZIntervalCount = slipCircle.SlipCircleGrid.ZIntervalNumber;
                slipCircleData.ZTopCenterPoint = slipCircle.SlipCircleGrid.GridZTop;
                aStabilityObjects.SetSlipCircleData(slipCircleData);
            }
            else if (aMStabProject.Stability.ModelOption == ModelOptions.HorizontalBalance)
            {
                HorizontalBalance(aMStabProject, ref aStabilityObjects);
            }
            else if (aMStabProject.Stability.ModelOption == ModelOptions.Spencer)
            {
                SpencerSlidePlaneData(aMStabProject, ref aStabilityObjects);
            }
            else if ((aMStabProject.Stability.ModelOption == ModelOptions.UpliftVan) ||
                     (aMStabProject.Stability.ModelOption == ModelOptions.UpliftSpencer))
            {
                UpliftCenterPointData(aMStabProject, ref aStabilityObjects);
            }
        }

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

            if (aMStabProject.Stability.SlipPlaneUpliftVan == null)
            {
                throw new DefinitionException("Empty UpliftVan in Definition in UpliftCenterPointData");
            }
            TSlipCircleData slipCircleData = aStabilityObjects.GetSlipCircleData();

            //Tangent line
            slipCircleData.TangentIntervalCount = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineNumber - 1;
            //aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineXLeft
            //aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineXRight 
            slipCircleData.BottomTangentZ = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineZBottom;
            slipCircleData.TopTangentZ = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneTangentLine.TangentLineZTop;

            //Left Grid (Active/Passive?)
            slipCircleData.XLeftCenterPoint = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft;
            slipCircleData.XIntervalCount = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXNumber - 1;
            slipCircleData.XRightCenterPoint = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridXRight;
            slipCircleData.ZBottomCenterPoint = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZBottom;
            slipCircleData.ZIntervalCount = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZNumber - 1;
            slipCircleData.ZTopCenterPoint = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneLeftGrid.GridZTop;

            //Right Grid (Active/Passive?)
            slipCircleData.XLeftCenterPointPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXLeft;
            slipCircleData.XIntervalCountPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXNumber - 1;
            slipCircleData.XRightCenterPointPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridXRight;
            slipCircleData.ZBottomCenterPointPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZBottom;
            slipCircleData.ZIntervalCountPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZNumber - 1;
            slipCircleData.ZTopCenterPointPassive = aMStabProject.Stability.SlipPlaneUpliftVan.SlipPlaneRightGrid.GridZTop;

            aStabilityObjects.SetSlipCircleData(slipCircleData);
        }

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

            if (aMStabProject.Stability.SlipPlanes == null)
            {
                throw new DefinitionException("Empty DefinitionSlipPlanes in Definition in SpencerSlidePlaneData");
            }

            TSpencerPlaneData spencerPlaneData = aStabilityObjects.GetSpencerPlaneData();

            if (aMStabProject.Stability.SlipPlanes.Count > 0)
            {
                spencerPlaneData.NumberofIntervals = aMStabProject.Stability.SlipInterval;
                spencerPlaneData.BottomLine = new TPoints[aMStabProject.Stability.SlipPlanes[0].Points.Count];

                for (int spencerIndex1 = 0; spencerIndex1 < aMStabProject.Stability.SlipPlanes[0].Points.Count; spencerIndex1++)
                {
                    spencerPlaneData.BottomLine[spencerIndex1].XCoor = aMStabProject.Stability.SlipPlanes[0].Points[spencerIndex1].X;
                    spencerPlaneData.BottomLine[spencerIndex1].ZCoor = aMStabProject.Stability.SlipPlanes[0].Points[spencerIndex1].Z;
                }
            }

            if (aMStabProject.Stability.SlipPlanes.Count > 1)
            {
                spencerPlaneData.Topline = new TPoints[aMStabProject.Stability.SlipPlanes[1].Points.Count];

                for (int spencerIndex2 = 0; spencerIndex2 < aMStabProject.Stability.SlipPlanes[1].Points.Count; spencerIndex2++)
                {
                    spencerPlaneData.Topline[spencerIndex2].XCoor = aMStabProject.Stability.SlipPlanes[1].Points[spencerIndex2].X;
                    spencerPlaneData.Topline[spencerIndex2].ZCoor = aMStabProject.Stability.SlipPlanes[1].Points[spencerIndex2].Z;
                }
            }

            spencerPlaneData.NumberofIntervals = aMStabProject.Stability.SlipInterval;

            aStabilityObjects.SetSpencerPlaneData(spencerPlaneData);
        }

        private static void HorizontalBalance(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            THorizontalbalanceData horizontalbalance = aStabilityObjects.GetHorizontalBalance();

            if (aMStabProject.Stability.HorizontalBalance == null)
            {
                return;
            }
            horizontalbalance.NumberOfIntervalOnZ = aMStabProject.Stability.HorizontalBalance.NZInterval;
            horizontalbalance.XCoormax = aMStabProject.Stability.HorizontalBalance.XRight;
            horizontalbalance.XCoorMin = aMStabProject.Stability.HorizontalBalance.XLeft;
            horizontalbalance.ZCoorTop = aMStabProject.Stability.HorizontalBalance.ZTop;
            horizontalbalance.ZCoorMin = aMStabProject.Stability.HorizontalBalance.ZBottom;
            aStabilityObjects.SetHorizontalBalance(horizontalbalance);
        }

        private static void ZoneAreas(MStabProject aMStabProject, ref TInterfaceData aStabilityObjects)
        {
            var zoneData = new TZoneData();
            zoneData.SafetyZone1a = aMStabProject.Stability.SafetyZoneAreas.SafetyZone1a;
            zoneData.SafetyZone1b = aMStabProject.Stability.SafetyZoneAreas.SafetyZone1b;
            zoneData.SafetyZone2a = aMStabProject.Stability.SafetyZoneAreas.SafetyZone2a;
            zoneData.SafetyZone2b = aMStabProject.Stability.SafetyZoneAreas.SafetyZone2b;
            zoneData.SafetyZone3a = aMStabProject.Stability.SafetyZoneAreas.SafetyZone3a;
            zoneData.SafetyZone3b = aMStabProject.Stability.SafetyZoneAreas.SafetyZone3b;
            zoneData.DikeTableHeight = aMStabProject.Stability.SafetyZoneAreas.DikeTableHeight;
            zoneData.StabilitySide = (TStabilitySideSet) aMStabProject.Stability.SafetyZoneAreas.Calculationside;
            zoneData.StandardOvertopping = aMStabProject.Stability.SafetyZoneAreas.StandardOvertopping == ZoneOvertoppingType.Standard;
            zoneData.XMHWInfluence = aMStabProject.Stability.SafetyZoneAreas.DesignLevelInfluenceX;
            zoneData.YMHWInfluence = aMStabProject.Stability.SafetyZoneAreas.DesignLevelInfluenceY;
            zoneData.XRoadLeft = aMStabProject.Stability.SafetyZoneAreas.LeftSideMinimalRoad;
            zoneData.XRoadRight = aMStabProject.Stability.SafetyZoneAreas.RightSideMinimalRoad;
            zoneData.RemoldingReductionFactor = aMStabProject.Stability.SafetyZoneAreas.RemoldingFactor;
            zoneData.SchematizationReductionFactor = aMStabProject.Stability.SafetyZoneAreas.SchematizationFactor;

            zoneData.IsDOVCalculation = aMStabProject.Stability.SafetyZoneAreas.ZonePolicy == ZonePolicy.DikesOnPeat;
            zoneData.XStartDOV = aMStabProject.Stability.SafetyZoneAreas.XStartDOV;
            zoneData.YStartDOV = aMStabProject.Stability.SafetyZoneAreas.YStartDOV;
            if (aMStabProject.Stability.SafetyZoneAreas.IsDOVCalculation)
            {
                // For DOV model, the dov required safety has to be used but that is NOT as such implemented in the kernel. 
                // That uses the SafetyZone1a so set proper value for that here in case of a DOV model.
                zoneData.SafetyZone1a = aMStabProject.Stability.SafetyZoneAreas.SafetyZone1DOV;
            }
            zoneData.XSafeprofileStart = aMStabProject.Stability.SafetyZoneAreas.XSafeProfileStart;

            zoneData.XStart = aMStabProject.Stability.SafetyZoneAreas.RestProfileStartX;
            aStabilityObjects.SetZoneData(zoneData);
        }
    }
}