using Deltares.Geometry;
using Deltares.Mathematics;
using Deltares.Standard;

namespace Deltares.Stability.Calculation2
{
    /// <summary>
    /// Checks whether 
    ///     A. the centre point isn't within the geometry
    ///     B. the exit point isn't above the centre point
    ///     C. the exit points aren't beyond the boundaries of he geometry
    /// </summary>
    internal class SlidingCurveWithGeometryValidator : ISlidingCurveValidator
    {
        private GeometryPointString surface;

        public SlidingCurveWithGeometryValidator(GeometryPointString surface)
        {
            this.surface = surface;
        }

        public bool IsValid(SlidingCurve slidingCurve)
        {
            // Bishop specific
            if (slidingCurve is SlidingCircle)
            {
                var bishopCircle = (SlidingCircle) slidingCurve;

                if (CentrePointsBelowExitPoints(bishopCircle))
                {
                    return false;
                }

                if (CentrePointsInGeometry(bishopCircle))
                {
                    return false;
                }

                if (ExitPointBeyondGeometry(bishopCircle.Center, bishopCircle.Radius))
                {
                    return false;
                }
            }

            if (slidingCurve is SlidingDualCircle)
            {
                var upliftPlane = (SlidingDualCircle) slidingCurve;

                if (CentrePointsBelowExitPoints(upliftPlane))
                {
                    return false;
                }

                if (CentrePointsInGeometry(upliftPlane))
                {
                    return false;
                }

                if (ExitPointBeyondGeometry(upliftPlane.ActiveCircle, upliftPlane.ActiveRadius) ||
                    ExitPointBeyondGeometry(upliftPlane.PassiveCircle, upliftPlane.PassiveRadius))
                {
                    return false;
                }
            }

            return true;
        }

        public bool SlicesMustBeFilled()
        {
            return false;
        }

        private bool ExitPointBeyondGeometry(Point2D point, double radius)
        {
            if (surface.Points.Count == 0)
            {
                return true;
            }

            double xOffsetLeft = point.X - surface.Points[0].X;
            double zOffsetLeft = point.Y - surface.Points[0].Z;

            if (radius*radius > xOffsetLeft*xOffsetLeft + zOffsetLeft*zOffsetLeft)
            {
                return true;
            }

            double xOffsetRight = point.X - surface.Points[surface.Points.Count - 1].X;
            double zOffsetRight = point.Y - surface.Points[surface.Points.Count - 1].Z;

            if (radius*radius > xOffsetRight*xOffsetRight + zOffsetRight*zOffsetRight)
            {
                return true;
            }

            return false;
        }

        private bool CentrePointsBelowExitPoints(SlidingCircle slidingCircle)
        {
            if (slidingCircle.Center.Y < slidingCircle.LeftPoint.Z)
            {
                return true;
            }

            if (slidingCircle.Center.Y < slidingCircle.RightPoint.Z)
            {
                return true;
            }
            return false;
        }

        private bool CentrePointsBelowExitPoints(SlidingDualCircle slidingCurve)
        {
            if (slidingCurve.ActiveCircle.Y < slidingCurve.LeftPoint.Z)
            {
                return true;
            }

            if (slidingCurve.PassiveCircle.Y < slidingCurve.RightPoint.Z)
            {
                return true;
            }
            return false;
        }

        private bool CentrePointsInGeometry(SlidingDualCircle slidingCurve)
        {
            double surfaceLevel = surface.GetZAtX(slidingCurve.ActiveCircle.X);
            if (surfaceLevel > slidingCurve.ActiveCircle.Y)
            {
                return true;
            }

            surfaceLevel = surface.GetZAtX(slidingCurve.PassiveCircle.X);
            if (surfaceLevel > slidingCurve.PassiveCircle.Y)
            {
                return true;
            }

            return false;
        }

        private bool CentrePointsInGeometry(SlidingCircle slidingCircle)
        {
            double surfaceLevel = surface.GetZAtX(slidingCircle.Center.X);
            if (surfaceLevel > slidingCircle.Center.Y)
            {
                return true;
            }

            return false;
        }
    }
}