using System;
using System.Collections.Generic;
using System.Diagnostics;
using Deltares.Geometry;
using Deltares.Stability;
using Deltares.Standard.Extensions;

namespace Deltares.MStab.IO.Classic
{
    internal class Definitions
    {
        /// <summary>
        /// TODO: Replace static reference to method argument (Variable now prevents garbage collection of this big object!)
        /// </summary>
        private StabilityModel mStabProject = null;

        /// <summary>
        /// Create all Definitions 
        /// </summary>
        public void GetDefinitions(int handle, StabilityModel stabilityModel,
                                   Dictionary<GeometrySurface, int> aSurfaceDictionary)
        {
            mStabProject = stabilityModel;

            try
            {
                if (mStabProject == null)
                {
                    throw new DefinitionException("Stability not instantiated");
                }

                if (mStabProject.Geometry == null)
                {
                    throw new DefinitionException("Geometry not instantiated");
                }

                SlipCircle(handle);
                ForbiddenLines(handle);
                ReferenceLevelForRatioCuCp(handle, aSurfaceDictionary);
                SlipPlanes(handle);
                HorizontalBalance(handle);
                SlipPlaneUpliftVan(handle);
                ZoneAreas(handle);
            }
            catch (DefinitionException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        /// <summary>
        /// SlipPlanes implementation
        /// </summary>
        private void SlipPlaneUpliftVan(int handle)
        {
            ClassicMStabFunctionDefinitions.MStabLiftSlipData classicSlipData = null;
            GetClassicMStab.GetClassicSlipLiftData(handle, ref classicSlipData);

            var newUpliftVan = new SlipPlaneUpliftVan();
            newUpliftVan.Name = "UpliftVan SlipPlane";
            var slipplaneleftgrid = new SlipCircleGrid();
            slipplaneleftgrid.GridZTop = classicSlipData.leftGridYtop;
            slipplaneleftgrid.GridXLeft = classicSlipData.leftGridXleft;
            slipplaneleftgrid.GridXNumber = classicSlipData.leftGridNX;
            slipplaneleftgrid.GridXRight = classicSlipData.leftGridXright;
            slipplaneleftgrid.GridZBottom = classicSlipData.leftGridYbottom;
            slipplaneleftgrid.GridZNumber = classicSlipData.leftGridNY;
            newUpliftVan.SlipPlaneLeftGrid = slipplaneleftgrid;

            var slipplanerightgrid = new SlipCircleGrid();
            slipplanerightgrid.GridZTop = classicSlipData.rightGridYtop;
            slipplanerightgrid.GridXLeft = classicSlipData.rightGridXleft;
            slipplanerightgrid.GridXNumber = classicSlipData.rightGridNX;
            slipplanerightgrid.GridXRight = classicSlipData.rightGridXright;
            slipplanerightgrid.GridZBottom = classicSlipData.rightGridYbottom;
            slipplanerightgrid.GridZNumber = classicSlipData.rightGridNY;
            newUpliftVan.SlipPlaneRightGrid = slipplanerightgrid;

            var tangentline = new SlipCircleTangentLine();
            tangentline.TangentLineNumber = classicSlipData.numberTangentLines;
            tangentline.TangentLineZBottom = classicSlipData.bottomTangentLine;
            tangentline.TangentLineZTop = classicSlipData.topTangentLine;
            tangentline.AutomaticAtBoundaries = classicSlipData.isAutomaticTangentUplift;
            newUpliftVan.SlipPlaneTangentLine = tangentline;
            mStabProject.Create(newUpliftVan);
        }

        /// <summary>
        /// SlipPlanes implementation
        /// </summary>
        private void SlipPlanes(int handle)
        {
            ClassicMStabFunctionDefinitions.MStabSlipSpencer spencerplanes1 = null;
            ClassicMStabFunctionDefinitions.MStabSlipSpencer spencerplanes2 = null;
            GetClassicMStab.GetClassicSpencer1(handle, ref spencerplanes1);
            GetClassicMStab.GetClassicSpencer2(handle, ref spencerplanes2);
            ClassicMStabFunctionDefinitions.MStabSlipInterval mStabSlipInterval = null;
            GetClassicMStab.GetClassicSlipInterval(handle, ref mStabSlipInterval);
            var newplane1 = new SlipPlane();
            newplane1.Name = "Slip Plane 1";
            mStabProject.SlipInterval = mStabSlipInterval.slipInterval;
            for (int i = 0; i < spencerplanes1.nCoordinates; i++)
            {
                var geoPointBegin = new GeometryPoint();
                geoPointBegin.X = spencerplanes1.points[i].x;
                geoPointBegin.Z = spencerplanes1.points[i].y;
                geoPointBegin.Y = 0;
                newplane1.Points.Add(geoPointBegin);
            }

            if (newplane1.Points.Count > 1)
            {
                mStabProject.Create(newplane1);
            }

            var newplane2 = new SlipPlane();
            newplane2.Name = "Slip Plane 2";
            mStabProject.SlipInterval = mStabSlipInterval.slipInterval;
            for (int i = 0; i < spencerplanes2.nCoordinates; i++)
            {
                var geoPointBegin = new GeometryPoint();
                geoPointBegin.X = spencerplanes2.points[i].x;
                geoPointBegin.Z = spencerplanes2.points[i].y;
                geoPointBegin.Y = 0;
                newplane2.Points.Add(geoPointBegin);
            }

            if (newplane2.Points.Count > 1)
            {
                mStabProject.Create(newplane2);
            }
        }

        /// <summary>
        /// Horizontal balance implementation
        /// </summary>
        private void HorizontalBalance(int handle)
        {
            ClassicMStabFunctionDefinitions.MStabHorizontalBalance classicHorizontalBalance = null;
            GetClassicMStab.GetClassicHorizontalBalance(handle, ref classicHorizontalBalance);

            var newHorizontalBalance = new HorizontalBalance();
            newHorizontalBalance.Name = "Horizontal Balance";
            newHorizontalBalance.NZInterval = classicHorizontalBalance.nYInterval;
            newHorizontalBalance.XLeft = classicHorizontalBalance.xLeft;
            newHorizontalBalance.XRight = classicHorizontalBalance.xRight;
            newHorizontalBalance.ZBottom = classicHorizontalBalance.yBottom;
            newHorizontalBalance.ZTop = classicHorizontalBalance.yTop;
            mStabProject.Create(newHorizontalBalance);
        }

        /// <summary>
        /// Slip circle implementation
        /// </summary>
        private void SlipCircle(int handle)
        {
            try
            {
                ClassicMStabFunctionDefinitions.MStabCircles circles = null;
                GetClassicMStab.GetClassicCircles(handle, ref circles);
                ClassicMStabFunctionDefinitions.MStabRequestedCircleSlices circleslices = null;
                GetClassicMStab.GetClassicRequestedCircleSlices(handle, ref circleslices);

                //SlipCircle Definition
                var slipcircle = new SlipCircle();
                slipcircle.Name = "SlipCircle";
                slipcircle.SlipCircleFixedPoint.UseFixedPoint = circles.bUseFixPoint;
                slipcircle.SlipCircleFixedPoint.XFixed = circles.xFixed;
                slipcircle.SlipCircleFixedPoint.ZFixed = circles.yFixed;

                var circlegrid = new SlipCircleGrid();
                circlegrid.Name = "SlipCircleGrid";
                circlegrid.GridXLeft = circles.gridXleft;
                circlegrid.GridXRight = circles.gridXRight;
                circlegrid.GridXNumber = circles.gridNX;
                circlegrid.GridZBottom = circles.gridYBottom;
                circlegrid.GridZTop = circles.gridYTop;
                circlegrid.GridZNumber = circles.gridNY;
                slipcircle.SlipCircleGrid = circlegrid;

                var tangentline = new SlipCircleTangentLine();
                tangentline.Name = "Tangentline";
                tangentline.TangentLineNumber = circles.nTan;
                tangentline.TangentLineZTop = circles.tanYtop;
                tangentline.TangentLineZBottom = circles.tanYBottom;
                slipcircle.SlipCircleTangentLine = tangentline;

                mStabProject.RequestedNumberOfSlices = circleslices.StriveCircle;
                mStabProject.Create(slipcircle);
            }
            catch (DefinitionException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        /// <summary>
        /// Forbidden Lines implementations
        /// </summary>
        private void ForbiddenLines(int handle)
        {
            try
            {
                ClassicMStabFunctionDefinitions.MStabForbiddenLines classicforbiddenlines = null;
                GetClassicMStab.GetClassicForbiddenLines(handle, ref classicforbiddenlines);

                for (int i = 0; i < classicforbiddenlines.numberLines; i++)
                {
                    var forbiddenlines = new ForbiddenLines();
                    forbiddenlines.Name = classicforbiddenlines.lines[i].itemName;

                    //Step one add forbidden points in non geometry list                    
                    var forbiddenline = new ForbiddenLines();
                    forbiddenline.StartX = classicforbiddenlines.lines[i].x1;
                    forbiddenline.StartZ = classicforbiddenlines.lines[i].y1;
                    forbiddenline.EndX = classicforbiddenlines.lines[i].x2;
                    forbiddenline.EndZ = classicforbiddenlines.lines[i].y2;
                    mStabProject.Create(forbiddenlines);
                }
            }
            catch (DefinitionException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        /// <summary>
        /// ReferenceLevelforRatioCuCp implementations
        /// </summary>
        private void ReferenceLevelForRatioCuCp(int handle, Dictionary<GeometrySurface, int> aSurfaceDictionary)
        {
            try
            {
                ClassicMStabFunctionDefinitions.MStabReferenceLevelCU referencelevelcu = null;
                GetClassicMStab.GetClassicReferenceCu(handle, ref referencelevelcu);

                ClassicGeometryFunctionDefinitions.GeometryBoundaries classicGeometryBoundaries = null;
                GetClassicGeometry.GetClassicGeometryBoundaries(handle, ref classicGeometryBoundaries);

                List<ClassicGeometryFunctionDefinitions.GeometryCurve> classicGeometryCurves = null;
                GetClassicGeometry.GetClassicGeometryCurves(handle, ref classicGeometryCurves);

                ClassicGeometryFunctionDefinitions.GeometryLayers classicGeometryLayers = null;
                GetClassicGeometry.GetClassicGeometryLayers(handle, ref classicGeometryLayers);

                List<ClassicGeometryFunctionDefinitions.GeometryPoint> classicGeometryPoints = null;
                GetClassicGeometry.GetClassicGeometryPoints(handle, ref classicGeometryPoints);

                int boundaryIndex = classicGeometryLayers.layers[referencelevelcu.cuReferenceLevel - 1].boundaryTopLayer;
                int numberCurvesTop = classicGeometryBoundaries.boundaries[boundaryIndex].numberOfCurvesOnBoundary;
                GeometryPoint geoPoint = null;
                var referenceline = new ReferenceLevelLine();

                for (int curvesTop = 0; curvesTop < numberCurvesTop; curvesTop++)
                {
                    int curveIndex = classicGeometryBoundaries.boundaries[boundaryIndex].curvesIndices[curvesTop] - 1;

                    if (curvesTop == 0)
                    {
                        geoPoint = mStabProject.Geometry.Points.Find(x => ((Math.Abs(x.X - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[0] - 1].x) < GeometryPoint.Precision) &&
                                                                           (Math.Abs(x.Y - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[0] - 1].z) < GeometryPoint.Precision) &&
                                                                           (Math.Abs(x.Z - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[0] - 1].y) < GeometryPoint.Precision)));
                        geoPoint = new GeometryPoint(geoPoint);
                        referenceline.Points.Add(geoPoint);
                    }
                    geoPoint = mStabProject.Geometry.Points.Find(x => ((Math.Abs(x.X - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[1] - 1].x) < GeometryPoint.Precision) &&
                                                                       (Math.Abs(x.Y - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[1] - 1].z) < GeometryPoint.Precision) &&
                                                                       (Math.Abs(x.Z - classicGeometryPoints[classicGeometryCurves[curveIndex].pointIndices[1] - 1].y) < GeometryPoint.Precision)));
                    geoPoint = new GeometryPoint(geoPoint);

                    referenceline.Points.Add(geoPoint);
                }

                //mStabProject.ReferenceLevelLine = referenceline;
                mStabProject.Create(referenceline);
                mStabProject.UpdateGeometryBounds();
            }
            catch (DefinitionException e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        private void ZoneAreas(int handle)
        {
            ClassicMStabFunctionDefinitions.MStabNewZonePlotData zonearea = null;
            GetClassicMStab.GetClassicPlotData(handle, ref zonearea);

            mStabProject.SafetyZoneAreas.DikeTableHeight = zonearea.dikeTableHeight;
            mStabProject.SafetyZoneAreas.SafetyZone1a = zonearea.safetyZone1a;
            mStabProject.SafetyZoneAreas.SafetyZone1b = zonearea.safetyZone1b;
            mStabProject.SafetyZoneAreas.SafetyZone2a = zonearea.safetyZone2a;
            mStabProject.SafetyZoneAreas.SafetyZone2b = zonearea.safetyZone2b;
            mStabProject.SafetyZoneAreas.SafetyZone3a = zonearea.safetyZone3a;
            mStabProject.SafetyZoneAreas.SafetyZone3b = zonearea.safetyZone3b;

            mStabProject.SafetyZoneAreas.Calculationside = (StabilityCalculationSide) zonearea.stabilitySide;
            mStabProject.SafetyZoneAreas.LeftSideMinimalRoad = zonearea.xRoadLeft;
            mStabProject.SafetyZoneAreas.RightSideMinimalRoad = zonearea.xRoadRight;
            mStabProject.SafetyZoneAreas.RestProfileStartX = zonearea.xStart;
            mStabProject.SafetyZoneAreas.DesignLevelInfluenceX = zonearea.xMHWInfluence;
            mStabProject.SafetyZoneAreas.DesignLevelInfluenceY = zonearea.yMHWInfluence;
            mStabProject.SafetyZoneAreas.StandardOvertopping = zonearea.standardOvertopping ? ZoneOvertoppingType.Standard : ZoneOvertoppingType.Extended;
        }
    }
}