using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Media;
using HandyControl.Expression.Drawing;

namespace HandyControl.Expression.Media;

internal class ArcGeometrySource : GeometrySource<IArcGeometrySourceParameters>
{
    private double _absoluteThickness;

    private double _relativeThickness;

    private static bool AreCloseEnough(double angleA, double angleB)
    {
        return Math.Abs(angleA - angleB) < 0.001;
    }

    internal static double[] ComputeAngleRanges(double radiusX, double radiusY, double intersect,
        double start, double end)
    {
        var values = new List<double>
        {
            start,
            end,
            intersect,
            180.0 - intersect,
            180.0 + intersect,
            360.0 - intersect,
            360.0 + intersect,
            540.0 - intersect,
            540.0 + intersect,
            720.0 - intersect
        };
        values.Sort();
        var index = values.IndexOf(start);
        var num2 = values.IndexOf(end);
        if (num2 == index)
        {
            num2++;
        }
        else if (start < end)
        {
            IncreaseDuplicatedIndex(values, ref index);
            DecreaseDuplicatedIndex(values, ref num2);
        }
        else if (start > end)
        {
            DecreaseDuplicatedIndex(values, ref index);
            IncreaseDuplicatedIndex(values, ref num2);
        }

        var list = new List<double>();
        if (index < num2)
            for (var i = index; i <= num2; i++)
                list.Add(values[i]);
        else
            for (var j = index; j >= num2; j--)
                list.Add(values[j]);
        var num5 = EnsureFirstQuadrant((list[0] + list[1]) / 2.0);
        if (radiusX < radiusY && num5 < intersect || radiusX > radiusY && num5 > intersect)
            list.RemoveAt(0);
        if (list.Count % 2 == 1) list.RemoveLast();
        if (list.Count == 0)
        {
            var num6 = Math.Min(index, num2) - 1;
            if (num6 < 0) num6 = Math.Max(index, num2) + 1;
            list.Add(values[num6]);
            list.Add(values[num6]);
        }

        return list.ToArray();
    }

    protected override Rect ComputeLogicalBounds(Rect layoutBounds, IGeometrySourceParameters parameters)
    {
        return GeometryHelper.GetStretchBound(base.ComputeLogicalBounds(layoutBounds, parameters),
            parameters.Stretch, new Size(1.0, 1.0));
    }

    private static IList<Point> ComputeOneInnerCurve(double start, double end, Rect bounds, double offset)
    {
        var num = bounds.Width / 2.0;
        var num2 = bounds.Height / 2.0;
        var point = bounds.Center();
        start = start * 3.1415926535897931 / 180.0;
        end = end * 3.1415926535897931 / 180.0;
        var num3 = 0.17453292519943295;
        var num4 = (int) Math.Ceiling(Math.Abs(end - start) / num3);
        num4 = Math.Max(2, num4);
        var list = new List<Point>(num4);
        var list2 = new List<Vector>(num4);
        var lhs = new Point();
        var item = new Point();
        var vector = new Vector();
        var vector2 = new Vector();
        var vector3 = new Vector();
        var vector4 = new Vector();
        for (var i = 0; i < num4; i++)
        {
            var a = MathHelper.Lerp(start, end, i / (double) (num4 - 1));
            var num10 = Math.Sin(a);
            var num11 = Math.Cos(a);
            lhs.X = point.X + num * num10;
            lhs.Y = point.Y - num2 * num11;
            vector.X = num * num11;
            vector.Y = num2 * num10;
            vector2.X = -num2 * num10;
            vector2.Y = num * num11;
            var d = num2 * num2 * num10 * num10 + num * num * num11 * num11;
            var num6 = Math.Sqrt(d);
            var num7 = 2.0 * num10 * num11 * (num2 * num2 - num * num);
            vector3.X = -num2 * num11;
            vector3.Y = -num * num10;
            item.X = lhs.X + offset * vector2.X / num6;
            item.Y = lhs.Y + offset * vector2.Y / num6;
            vector4.X = vector.X + offset / num6 * (vector3.X - 0.5 * vector2.X / d * num7);
            vector4.Y = vector.Y + offset / num6 * (vector3.Y - 0.5 * vector2.Y / d * num7);
            list.Add(item);
            list2.Add(-vector4.Normalized());
        }

        var list3 = new List<Point>(num4 * 3 + 1)
        {
            list[0]
        };
        for (var j = 1; j < num4; j++)
        {
            lhs = list[j - 1];
            item = list[j];
            var num13 = GeometryHelper.Distance(lhs, item) / 3.0;
            list3.Add(lhs + list2[j - 1] * num13);
            list3.Add(item - list2[j] * num13);
            list3.Add(item);
        }

        return list3;
    }

    private static void DecreaseDuplicatedIndex(IList<double> values, ref int index)
    {
        // ReSharper disable once CompareOfFloatsByEqualityOperator
        while (index > 0 && values[index] == values[index - 1]) index--;
    }

    internal static double EnsureFirstQuadrant(double angle)
    {
        angle = Math.Abs(angle % 180.0);
        if (angle <= 90.0) return angle;
        return 180.0 - angle;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static Size GetArcSize(Rect bound)
    {
        return new(bound.Width / 2.0, bound.Height / 2.0);
    }

    private static void IncreaseDuplicatedIndex(IList<double> values, ref int index)
    {
        // ReSharper disable once CompareOfFloatsByEqualityOperator
        while (index < values.Count - 1 && values[index] == values[index + 1]) index++;
    }

    internal static double InnerCurveSelfIntersect(double radiusX, double radiusY, double thickness)
    {
        var angleA = 0.0;
        var angleB = 1.5707963267948966;
        var flag = radiusX <= radiusY;
        var vector = new Vector();
        while (!AreCloseEnough(angleA, angleB))
        {
            var d = (angleA + angleB) / 2.0;
            var num4 = Math.Cos(d);
            var num5 = Math.Sin(d);
            vector.X = radiusY * num5;
            vector.Y = radiusX * num4;
            vector.Normalize();
            if (flag)
            {
                var num6 = radiusX * num5 - vector.X * thickness;
                if (num6 > 0.0)
                    angleB = d;
                else if (num6 < 0.0) angleA = d;
            }
            else
            {
                var num7 = radiusY * num4 - vector.Y * thickness;
                if (num7 < 0.0)
                    angleB = d;
                else if (num7 > 0.0) angleA = d;
            }
        }

        var num8 = (angleA + angleB) / 2.0;
        if (AreCloseEnough(num8, 0.0)) return 0.0;
        if (!AreCloseEnough(num8, 1.5707963267948966)) return num8 * 180.0 / 3.1415926535897931;
        return 90.0;
    }

    private static double NormalizeAngle(double degree)
    {
        if (degree < 0.0 || degree > 360.0)
        {
            degree = degree % 360.0;
            if (degree < 0.0) degree += 360.0;
        }

        return degree;
    }

    private void NormalizeThickness(IArcGeometrySourceParameters parameters)
    {
        var num = LogicalBounds.Width / 2.0;
        var num2 = LogicalBounds.Height / 2.0;
        var rhs = Math.Min(num, num2);
        var arcThickness = parameters.ArcThickness;
        if (parameters.ArcThicknessUnit == UnitType.Pixel)
            arcThickness = MathHelper.SafeDivide(arcThickness, rhs, 0.0);
        _relativeThickness = MathHelper.EnsureRange(arcThickness, 0.0, 1.0);
        _absoluteThickness = rhs * _relativeThickness;
    }

    private bool SyncPieceWiseInnerCurves(PathFigure figure, int index, ref Point firstPoint,
        params double[] angles)
    {
        var flag = false;
        var length = angles.Length;
        var logicalBounds = LogicalBounds;
        var absoluteThickness = _absoluteThickness;
        flag |= figure.Segments.EnsureListCount(index + length / 2, () => new PolyBezierSegment());
        for (var i = 0; i < length / 2; i++)
        {
            var points = ComputeOneInnerCurve(angles[i * 2], angles[i * 2 + 1], logicalBounds,
                absoluteThickness);
            if (i == 0) firstPoint = points[0];
            flag |= PathSegmentHelper.SyncPolyBezierSegment(figure.Segments, index + i, points, 1,
                points.Count - 1);
        }

        return flag;
    }

    [SuppressMessage("ReSharper", "ConditionIsAlwaysTrueOrFalse")]
    [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
    protected override bool UpdateCachedGeometry(IArcGeometrySourceParameters parameters)
    {
        var flag = false;
        NormalizeThickness(parameters);
        var relativeMode = parameters.ArcThicknessUnit == UnitType.Percent;
        var flag3 = MathHelper.AreClose(parameters.StartAngle, parameters.EndAngle);
        var angle = NormalizeAngle(parameters.StartAngle);
        var end = NormalizeAngle(parameters.EndAngle);
        if (end < angle) end += 360.0;
        var isFilled = _relativeThickness == 1.0;
        var flag5 = _relativeThickness == 0.0;
        if (flag3) return flag | UpdateZeroAngleGeometry(relativeMode, angle);
        if (MathHelper.IsVerySmall((end - angle) % 360.0))
        {
            if (flag5 || isFilled) return flag | UpdateEllipseGeometry(isFilled);
            return flag | UpdateFullRingGeometry(relativeMode);
        }

        if (isFilled) return flag | UpdatePieGeometry(angle, end);
        if (flag5) return flag | UpdateOpenArcGeometry(angle, end);
        return flag | UpdateRingArcGeometry(relativeMode, angle, end);
    }

    private bool UpdateEllipseGeometry(bool isFilled)
    {
        var flag = false;
        var y = MathHelper.Lerp(LogicalBounds.Top, LogicalBounds.Bottom, 0.5);
        var point = new Point(LogicalBounds.Left, y);
        var point2 = new Point(LogicalBounds.Right, y);
        flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
            () => new PathGeometry());
        flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
        var dependencyObject = geometry.Figures[0];
        flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
        flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, isFilled);
        flag |= dependencyObject.Segments.EnsureListCount(2, () => new ArcSegment());
        flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty, point);
        flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
            () => new ArcSegment());
        flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
            () => new ArcSegment());
        var size = new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0);
        flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
        flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, size);
        flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
        flag |= segment.SetIfDifferent(ArcSegment.PointProperty, point2);
        flag |= segment2.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
        flag |= segment2.SetIfDifferent(ArcSegment.SizeProperty, size);
        flag |= segment2.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
        return flag | segment2.SetIfDifferent(ArcSegment.PointProperty, point);
    }

    private bool UpdateFullRingGeometry(bool relativeMode)
    {
        var flag = false;
        flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
            () => new PathGeometry());
        flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.EvenOdd);
        flag |= geometry.Figures.EnsureListCount(2, () => new PathFigure());
        flag |= PathFigureHelper.SyncEllipseFigure(geometry.Figures[0], LogicalBounds,
            SweepDirection.Clockwise);
        var logicalBounds = LogicalBounds;
        var num = logicalBounds.Width / 2.0;
        var num2 = logicalBounds.Height / 2.0;
        if (relativeMode || MathHelper.AreClose(num, num2))
        {
            var bounds = LogicalBounds.Resize(1.0 - _relativeThickness);
            return flag | PathFigureHelper.SyncEllipseFigure(geometry.Figures[1], bounds,
                SweepDirection.Counterclockwise);
        }

        flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsClosedProperty, true);
        flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsFilledProperty, true);
        var firstPoint = new Point();
        var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
        var angles = ComputeAngleRanges(num, num2, intersect, 360.0, 0.0);
        flag |= SyncPieceWiseInnerCurves(geometry.Figures[1], 0, ref firstPoint, angles);
        return flag | geometry.Figures[1].SetIfDifferent(PathFigure.StartPointProperty, firstPoint);
    }

    private bool UpdateOpenArcGeometry(double start, double end)
    {
        PathFigure figure;
        ArcSegment segment;
        var flag = false;
        var cachedGeometry = CachedGeometry as PathGeometry;
        if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
            (figure = cachedGeometry.Figures[0]).Segments.Count != 1 ||
            (segment = figure.Segments[0] as ArcSegment) == null)
        {
            figure = new PathFigure();
            CachedGeometry = new PathGeometry
            {
                Figures = { figure }
            };
            figure.Segments.Add(segment = new ArcSegment());
            figure.IsClosed = false;
            segment.SweepDirection = SweepDirection.Clockwise;
            flag = true;
        }

        flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
            GeometryHelper.GetArcPoint(start, LogicalBounds));
        flag |= figure.SetIfDifferent(PathFigure.IsFilledProperty, false);
        flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
            GeometryHelper.GetArcPoint(end, LogicalBounds));
        flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
        return flag | segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
    }

    private bool UpdatePieGeometry(double start, double end)
    {
        PathFigure figure;
        ArcSegment segment;
        LineSegment segment2;
        var flag = false;
        var cachedGeometry = CachedGeometry as PathGeometry;
        if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
            (figure = cachedGeometry.Figures[0]).Segments.Count != 2 ||
            (segment = figure.Segments[0] as ArcSegment) == null ||
            (segment2 = figure.Segments[1] as LineSegment) == null)
        {
            figure = new PathFigure();
            CachedGeometry = new PathGeometry
            {
                Figures = { figure }
            };
            figure.Segments.Add(segment = new ArcSegment());
            figure.Segments.Add(segment2 = new LineSegment());
            figure.IsClosed = true;
            segment.SweepDirection = SweepDirection.Clockwise;
            flag = true;
        }

        flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
            GeometryHelper.GetArcPoint(start, LogicalBounds));
        flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
            GeometryHelper.GetArcPoint(end, LogicalBounds));
        flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
        flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
        return flag | segment2.SetIfDifferent(LineSegment.PointProperty, LogicalBounds.Center());
    }

    private bool UpdateRingArcGeometry(bool relativeMode, double start, double end)
    {
        var flag = false;
        flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
            () => new PathGeometry());
        flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.Nonzero);
        flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
        var dependencyObject = geometry.Figures[0];
        flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
        flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, true);
        flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty,
            GeometryHelper.GetArcPoint(start, LogicalBounds));
        flag |= dependencyObject.Segments.EnsureListCountAtLeast(3, () => new ArcSegment());
        flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
            () => new ArcSegment());
        flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
            GeometryHelper.GetArcPoint(end, LogicalBounds));
        flag |= segment.SetIfDifferent(ArcSegment.SizeProperty,
            new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0));
        flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
        flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
        flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
            () => new LineSegment());
        var logicalBounds = LogicalBounds;
        var num = logicalBounds.Width / 2.0;
        var num2 = logicalBounds.Height / 2.0;
        if (relativeMode || MathHelper.AreClose(num, num2))
        {
            var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
            flag |= segment2.SetIfDifferent(LineSegment.PointProperty,
                GeometryHelper.GetArcPoint(end, bound));
            flag |= dependencyObject.Segments.EnsureListCount(3, () => new ArcSegment());
            flag |= GeometryHelper.EnsureSegmentType(out var segment3, dependencyObject.Segments, 2,
                () => new ArcSegment());
            flag |= segment3.SetIfDifferent(ArcSegment.PointProperty,
                GeometryHelper.GetArcPoint(start, bound));
            flag |= segment3.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(bound));
            flag |= segment3.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
            return flag | segment3.SetIfDifferent(ArcSegment.SweepDirectionProperty,
                SweepDirection.Counterclockwise);
        }

        var firstPoint = new Point();
        var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
        var angles = ComputeAngleRanges(num, num2, intersect, end, start);
        flag |= SyncPieceWiseInnerCurves(dependencyObject, 2, ref firstPoint, angles);
        return flag | segment2.SetIfDifferent(LineSegment.PointProperty, firstPoint);
    }

    private bool UpdateZeroAngleGeometry(bool relativeMode, double angle)
    {
        Point point2;
        var flag = false;
        var arcPoint = GeometryHelper.GetArcPoint(angle, LogicalBounds);
        var logicalBounds = LogicalBounds;
        var num = logicalBounds.Width / 2.0;
        var num2 = logicalBounds.Height / 2.0;
        if (relativeMode || MathHelper.AreClose(num, num2))
        {
            var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
            point2 = GeometryHelper.GetArcPoint(angle, bound);
        }
        else
        {
            var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
            var numArray = ComputeAngleRanges(num, num2, intersect, angle, angle);
            var a = numArray[0] * 3.1415926535897931 / 180.0;
            var vector = new Vector(num2 * Math.Sin(a), -num * Math.Cos(a));
            point2 = GeometryHelper.GetArcPoint(numArray[0], LogicalBounds) -
                     vector.Normalized() * _absoluteThickness;
        }

        flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
            () => new LineGeometry());
        flag |= geometry.SetIfDifferent(LineGeometry.StartPointProperty, arcPoint);
        return flag | geometry.SetIfDifferent(LineGeometry.EndPointProperty, point2);
    }
}