using System;
using System.Collections.Generic;
using Deltares.Geometry;

namespace Deltares.Stability.Calculation2
{
    public class IntersectsForbiddenLineValidation : ISlidingCurveValidator
    {
        private List<ForbiddenLines> forbiddenLinesList;

        public IntersectsForbiddenLineValidation(List<ForbiddenLines> forbiddenLinesList)
        {
            this.forbiddenLinesList = forbiddenLinesList;
        }

        public bool IsValid(SlidingCurve slidingCurve)
        {
            if (slidingCurve is SlidingDualCircle)
            {
                if (CheckUpliftPlaneIntersectsForbiddenLines((SlidingDualCircle) slidingCurve))
                {
                    return false;
                }
                return true;
            }

            if (slidingCurve is SlidingCircle)
            {
                if (CheckCircleIntersectsForbiddenLines((SlidingCircle) slidingCurve))
                {
                    return false;
                }
                return true;
            }

            if (slidingCurve is SlidingPlane)
            {
                if (CheckSpencerPlaneIntersectsForbiddenLines((SlidingPlane) slidingCurve))
                {
                    return false;
                }
                return true;
            }

            return true;
        }

        public bool SlicesMustBeFilled()
        {
            return false;
        }

        protected bool CheckSpencerPlaneIntersectsForbiddenLines(SlidingPlane slidingPlane)
        {
            int i;
            Line line;
            Line lineBottom;
            var leftPoint = new GeometryPoint();
            var rightPoint = new GeometryPoint();

            for (i = 0; i < forbiddenLinesList.Count; i++)
            {
                if ((Math.Max(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) > slidingPlane.LeftPoint.X) &&
                    (Math.Min(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) < slidingPlane.RightPoint.X))
                {
                    // intersects with active part ?
                    line = new Line(forbiddenLinesList[i].StartPoint, forbiddenLinesList[i].EndPoint);
                    for (int j = 0; j < slidingPlane.SpencerSlipPlane.Count - 1; j++) {}
                    leftPoint.X = slidingPlane.SpencerSlipPlane[i].X;
                    leftPoint.Z = slidingPlane.SpencerSlipPlane[i].Y;
                    rightPoint.X = slidingPlane.SpencerSlipPlane[i + 1].X;
                    rightPoint.Z = slidingPlane.SpencerSlipPlane[i + 1].Y;
                    lineBottom = new Line(leftPoint, rightPoint);

                    GeometryPoint intersectPoint = line.GetIntersectPointXZ(lineBottom);
                    if (intersectPoint != null)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        protected bool CheckCircleIntersectsForbiddenLines(SlidingCircle slidingCircle)
        {
            int i;
            Line line;
            double xm;
            double zm;
            double lRadius;

            for (i = 0; i < forbiddenLinesList.Count; i++)
            {
                if ((Math.Max(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) > slidingCircle.LeftPoint.X) &&
                    (Math.Min(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) < slidingCircle.RightPoint.X))
                {
                    // intersects with active part ?
                    line = new Line(forbiddenLinesList[i].StartPoint, forbiddenLinesList[i].EndPoint);
                    xm = slidingCircle.Center.X;
                    zm = slidingCircle.Center.Y;
                    lRadius = slidingCircle.Radius;
                    if (LineHelper.CircleIntersectsLine(xm, zm, lRadius, line))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        protected bool CheckUpliftPlaneIntersectsForbiddenLines(SlidingDualCircle upliftPlane)
        {
            int i;
            Line line;
            Line lineBottom;
            double xm;
            double zm;
            double lRadius;
            double xStart;
            double xEnd;
            for (i = 0; i < forbiddenLinesList.Count; i++)
            {
                if ((Math.Max(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) > upliftPlane.LeftPoint.X) &&
                    (Math.Min(forbiddenLinesList[i].StartX, forbiddenLinesList[i].EndX) < upliftPlane.RightPoint.X))
                {
                    // intersects with active part ?
                    line = new Line(forbiddenLinesList[i].StartPoint, forbiddenLinesList[i].EndPoint);
                    xm = upliftPlane.ActiveCircle.X;
                    zm = upliftPlane.ActiveCircle.Y;
                    lRadius = zm - upliftPlane.TangentLine;
                    xStart = upliftPlane.LeftPoint.X;
                    if (LineHelper.Intersect_Circle_line_InInterval(xm, zm, lRadius, line, xStart, xm))
                    {
                        return true;
                    }

                    // intersects with horizontal part
                    var leftPoint = new GeometryPoint(upliftPlane.ActiveCircle.X, 0, upliftPlane.TangentLine);
                    var rightPoint = new GeometryPoint(upliftPlane.PassiveCircle.X, 0, upliftPlane.TangentLine);
                    lineBottom = new Line(leftPoint, rightPoint);

                    GeometryPoint intersectPoint = line.GetIntersectPointXZ(lineBottom);
                    if (intersectPoint != null)
                    {
                        return true;
                    }

                    // intersects with passive part ?
                    xm = upliftPlane.PassiveCircle.X;
                    zm = upliftPlane.PassiveCircle.Y;
                    lRadius = zm - upliftPlane.TangentLine;
                    xEnd = upliftPlane.RightPoint.X;
                    if (LineHelper.Intersect_Circle_line_InInterval(xm, zm, lRadius, line, xm, xEnd))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}