using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using AntDesignWPF.Utils;

namespace AntDesignWPF.Controls;

/// <summary>
/// Draws a border, background, or both around another element.
/// </summary>
public class AntBorder : Decorator
{
    #region Fields

    private StreamGeometry backgroundGeometryCache;

    private StreamGeometry upperLeftCache;

    private StreamGeometry upperRightCache;

    private StreamGeometry lowerRightCache;

    private StreamGeometry lowerLeftCache;

    private bool useComplexRender;

    private Pen leftPenCache;

    private Pen topPenCache;

    private Pen rightPenCache;

    private Pen bottomPenCache;

    #endregion

    #region Properties

    public static readonly DependencyProperty BackgroundProperty = DependencyProperty.Register(
        "Background",
        typeof(Brush),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
            null,
            FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender
        ));

    /// <summary>
    /// Gets or sets the brush that fills the area between the bounds of a Border.
    /// </summary>
    public Brush Background
    {
        get { return (Brush)GetValue(BackgroundProperty); }
        set { SetValue(BackgroundProperty, value); }
    }

    public static readonly DependencyProperty BorderBrushProperty = DependencyProperty.Register(
        "BorderBrush",
        typeof(Brush),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
            null,
            FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
            OnClearPenCache
        ));

    /// <summary>
    /// Gets or sets the brush that draws the outer border color.
    /// </summary>
    public Brush BorderBrush
    {
        get { return (Brush)GetValue(BorderBrushProperty); }
        set { SetValue(BorderBrushProperty, value); }
    }

    public static readonly DependencyProperty BorderThicknessProperty = DependencyProperty.Register(
        "BorderThickness",
        typeof(Thickness),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
             new Thickness(),
             FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender,
             OnClearPenCache
        ),
        IsThicknessValid);

    /// <summary>
    /// Gets or sets the relative thickness of a border.
    /// </summary>
    public Thickness BorderThickness
    {
        get { return (Thickness)GetValue(BorderThicknessProperty); }
        set { SetValue(BorderThicknessProperty, value); }
    }

    private static void OnClearPenCache(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var border = (AntBorder)d;
        border.leftPenCache = border.topPenCache = border.rightPenCache = border.bottomPenCache = null;
    }

    private static bool IsThicknessValid(object value)
    {
        return ThicknessUtil.IsValid((Thickness)value, false, false, false, false);
    }

    public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.Register(
        "CornerRadius",
        typeof(CornerRadius),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
            new CornerRadius(),
            FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender
        ),
        IsCornerRadiusValid);

    /// <summary>
    /// Gets or sets a value that represents the degree to which the corners of a Border are rounded.
    /// </summary>
    public CornerRadius CornerRadius
    {
        get { return (CornerRadius)GetValue(CornerRadiusProperty); }
        set { SetValue(CornerRadiusProperty, value); }
    }

    private static bool IsCornerRadiusValid(object value)
    {
        return CornerRadiusUtil.IsValid((CornerRadius)value, false, false, false, false);
    }

    public static readonly DependencyProperty PaddingProperty = DependencyProperty.Register(
        "Padding",
        typeof(Thickness),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
            new Thickness(),
            FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsRender
        ),
        IsThicknessValid);

    /// <summary>
    /// Gets or sets a thickness value that describes the amount of space between a border and its child element.
    /// </summary>
    public Thickness Padding
    {
        get { return (Thickness)GetValue(PaddingProperty); }
        set { SetValue(PaddingProperty, value); }
    }

    public static readonly DependencyProperty BorderStyleProperty = DependencyProperty.Register(
        "BorderStyle",
        typeof(BorderStyle),
        typeof(AntBorder),
        new FrameworkPropertyMetadata(
            BorderStyle.Solid,
            FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.SubPropertiesDoNotAffectRender,
            OnClearPenCache
        ));

    /// <summary>
    /// Gets or sets the border style.
    /// </summary>
    public BorderStyle BorderStyle
    {
        get { return (BorderStyle)GetValue(BorderStyleProperty); }
        set { SetValue(BorderStyleProperty, value); }
    }

    #endregion

    #region Overrides

    /// <summary>
    /// Updates DesiredSize of the Border.  Called by parent UIElement.  This is the first pass of layout.
    /// </summary>
    /// <remarks>
    /// Border determines its desired size it needs from the specified border the child: its sizing
    /// properties, margin, and requested size.
    /// </remarks>
    /// <param name="constraint">Constraint size is an "upper limit" that the return value should not exceed.</param>
    /// <returns>The Decorator's desired size.</returns>
    protected override Size MeasureOverride(Size constraint)
    {
        var child = Child;
        var desiredSize = new Size();
        var borders = BorderThickness;

        if (UseLayoutRounding)
        {
            var dpi = DpiUtil.GetDpi(this);
            borders = new Thickness(UIElementUtil.RoundLayoutValue(borders.Left, dpi.DpiScaleX), UIElementUtil.RoundLayoutValue(borders.Top, dpi.DpiScaleY),
               UIElementUtil.RoundLayoutValue(borders.Right, dpi.DpiScaleX), UIElementUtil.RoundLayoutValue(borders.Bottom, dpi.DpiScaleY));
        }

        // Compute the total size required
        var borderSize = ThicknessUtil.CollapseThickness(borders);
        var paddingSize = ThicknessUtil.CollapseThickness(Padding);

        // If we have a child
        if (child != null)
        {
            // Combine into total decorating size
            var combined = new Size(borderSize.Width + paddingSize.Width, borderSize.Height + paddingSize.Height);

            // Remove size of border only from child's reference size.
            var childConstraint = new Size(Math.Max(0.0, constraint.Width - combined.Width),
                                            Math.Max(0.0, constraint.Height - combined.Height));


            child.Measure(childConstraint);
            var childSize = child.DesiredSize;

            // Now use the returned size to drive our size, by adding back the margins, etc.
            desiredSize.Width = childSize.Width + combined.Width;
            desiredSize.Height = childSize.Height + combined.Height;
        }
        else
        {
            // Combine into total decorating size
            desiredSize = new Size(borderSize.Width + paddingSize.Width, borderSize.Height + paddingSize.Height);
        }

        return desiredSize;
    }

    /// <summary>
    /// Border computes the position of its single child and applies its child's alignments to the child.
    /// </summary>
    /// <param name="finalSize">The size reserved for this element by the parent</param>
    /// <returns>The actual ink area of the element, typically the same as finalSize</returns>
    protected override Size ArrangeOverride(Size finalSize)
    {
        var borders = BorderThickness;

        if (UseLayoutRounding)
        {
            var dpi = DpiUtil.GetDpi(this);
            borders = new Thickness(UIElementUtil.RoundLayoutValue(borders.Left, dpi.DpiScaleX), UIElementUtil.RoundLayoutValue(borders.Top, dpi.DpiScaleY),
               UIElementUtil.RoundLayoutValue(borders.Right, dpi.DpiScaleX), UIElementUtil.RoundLayoutValue(borders.Bottom, dpi.DpiScaleY));
        }

        var boundRect = new Rect(finalSize);
        var innerRect = RectUtil.Deflate(boundRect, borders);

        //  arrange child
        var child = Child;
        if (child != null)
        {
            Rect childRect = RectUtil.Deflate(innerRect, Padding);
            child.Arrange(childRect);
        }

        var radius = CornerRadius;

        useComplexRender = !CornerRadiusUtil.IsUniform(radius) || !ThicknessUtil.IsUniform(borders);
        backgroundGeometryCache = upperLeftCache = upperRightCache = lowerRightCache = lowerLeftCache = null;

        if (useComplexRender)
        {
            //  calculate border / background rendering geometry
            if (!DoubleUtil.IsZero(boundRect.Width) && !DoubleUtil.IsZero(boundRect.Height))
            {
                var outerRadii = new Radii(boundRect, radius, borders, true);

                // Upper-right corner
                var radiusX = boundRect.TopRight.X - outerRadii.TopRight.X;
                var radiusY = outerRadii.RightTop.Y - boundRect.TopRight.Y;
                if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                {
                    upperRightCache = GenerateRoundedGeometry(outerRadii.TopRight, outerRadii.RightTop, new Size(radiusX, radiusY));
                }

                // Lower-right corner
                radiusX = boundRect.BottomRight.X - outerRadii.BottomRight.X;
                radiusY = boundRect.BottomRight.Y - outerRadii.RightBottom.Y;
                if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                {
                    lowerRightCache = GenerateRoundedGeometry(outerRadii.RightBottom, outerRadii.BottomRight, new Size(radiusX, radiusY));
                }

                // Lower-left corner
                radiusX = outerRadii.BottomLeft.X - boundRect.BottomLeft.X;
                radiusY = boundRect.BottomLeft.Y - outerRadii.LeftBottom.Y;
                if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                {
                    lowerLeftCache = GenerateRoundedGeometry(outerRadii.BottomLeft, outerRadii.LeftBottom, new Size(radiusX, radiusY));
                }

                // Upper-left corner
                radiusX = outerRadii.TopLeft.X - boundRect.TopLeft.X;
                radiusY = outerRadii.LeftTop.Y - boundRect.TopLeft.Y;
                if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                {
                    upperLeftCache = GenerateRoundedGeometry(outerRadii.LeftTop, outerRadii.TopLeft, new Size(radiusX, radiusY));
                }
            }

            if (!DoubleUtil.IsZero(innerRect.Width) && !DoubleUtil.IsZero(innerRect.Height))
            {
                var innerRadii = new Radii(innerRect, radius, borders, false);
                var backgroundGeometry = new StreamGeometry();

                using (StreamGeometryContext sc = backgroundGeometry.Open())
                {
                    //  create the border geometry
                    sc.BeginFigure(innerRadii.TopLeft, true /* is filled */, true /* is closed */);

                    // Top line
                    sc.LineTo(innerRadii.TopRight, true /* is stroked */, false /* is smooth join */);

                    // Upper-right corners
                    var radiusX = innerRect.TopRight.X - innerRadii.TopRight.X;
                    var radiusY = innerRadii.RightTop.Y - innerRect.TopRight.Y;
                    if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                    {
                        sc.ArcTo(innerRadii.RightTop, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise, true, false);
                    }

                    // Right line
                    sc.LineTo(innerRadii.RightBottom, true /* is stroked */, false /* is smooth join */);

                    // Lower-right corners
                    radiusX = innerRect.BottomRight.X - innerRadii.BottomRight.X;
                    radiusY = innerRect.BottomRight.Y - innerRadii.RightBottom.Y;
                    if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                    {
                        sc.ArcTo(innerRadii.BottomRight, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise, true, false);
                    }

                    // Bottom line
                    sc.LineTo(innerRadii.BottomLeft, true /* is stroked */, false /* is smooth join */);

                    // Lower-left corners
                    radiusX = innerRadii.BottomLeft.X - innerRect.BottomLeft.X;
                    radiusY = innerRect.BottomLeft.Y - innerRadii.LeftBottom.Y;
                    if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                    {
                        sc.ArcTo(innerRadii.LeftBottom, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise, true, false);
                    }

                    // Left line
                    sc.LineTo(innerRadii.LeftTop, true /* is stroked */, false /* is smooth join */);

                    // Upper-left corners
                    radiusX = innerRadii.TopLeft.X - innerRect.TopLeft.X;
                    radiusY = innerRadii.LeftTop.Y - innerRect.TopLeft.Y;
                    if (!DoubleUtil.IsZero(radiusX) || !DoubleUtil.IsZero(radiusY))
                    {
                        sc.ArcTo(innerRadii.TopLeft, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise, true, false);
                    }
                }

                backgroundGeometry.Freeze();
                backgroundGeometryCache = backgroundGeometry;
            }
        }

        return finalSize;
    }

    protected override void OnRender(DrawingContext dc)
    {
        if (useComplexRender)
        {
            ComplexRender(dc);
        } else
        {
            SimpleRender(dc);
        }
    }

    #endregion

    #region Private Methods

    private void SimpleRender(DrawingContext dc)
    {
        var useLayoutRounding = UseLayoutRounding;
        var dpi = DpiUtil.GetDpi(this);

        Brush brush; 
        var borderStyle = BorderStyle;

        var borders = BorderThickness;
        var cornerRadius = CornerRadius;

        var outerCornerRadius = cornerRadius.TopLeft; // Already validated that all corners have the same radius
        var roundedCorners = !DoubleUtil.IsZero(outerCornerRadius);

        var width = RenderSize.Width;
        var height = RenderSize.Height;

        // Draw border
        if (!ThicknessUtil.IsZero(borders) && (brush = BorderBrush) != null)
        {
            var pen = GetPen(brush, borderStyle, borders.Left, dpi.DpiScaleX, useLayoutRounding);
            var penThickness = pen.Thickness;

            double x = penThickness * 0.5;
            var rect = new Rect(x, x, width - penThickness, height - penThickness);

            if (roundedCorners)
            {
                dc.DrawRoundedRectangle(null, pen, rect, outerCornerRadius, outerCornerRadius);
            }
            else
            {
                dc.DrawRectangle(null, pen, rect);
            }
        }

        // Draw background in rectangle inside border.
        if ((brush = Background) != null)
        {
            // Intialize background 
            Point ptTL, ptBR;

            if (useLayoutRounding)
            {
                ptTL = new Point(UIElementUtil.RoundLayoutValue(borders.Left, dpi.DpiScaleX),
                                 UIElementUtil.RoundLayoutValue(borders.Top, dpi.DpiScaleY));
                ptBR = new Point(width - UIElementUtil.RoundLayoutValue(borders.Right, dpi.DpiScaleX),
                                 height - UIElementUtil.RoundLayoutValue(borders.Bottom, dpi.DpiScaleY));
            }
            else
            {
                ptTL = new Point(borders.Left, borders.Top);
                ptBR = new Point(width - borders.Right, height - borders.Bottom);
            }

            // Do not draw background if the borders are so large that they overlap.
            if (ptBR.X > ptTL.X && ptBR.Y > ptTL.Y)
            {
                if (roundedCorners)
                {
                    // Determine the inner edge radius
                    var innerCornerRadius = Math.Max(0.0, outerCornerRadius - borders.Top * 0.5);
                    dc.DrawRoundedRectangle(brush, null, new Rect(ptTL, ptBR), innerCornerRadius, innerCornerRadius);
                }
                else
                {
                    dc.DrawRectangle(brush, null, new Rect(ptTL, ptBR));
                }
            }
        }
    }

    private void ComplexRender(DrawingContext dc)
    {
        Brush brush;
        var width = RenderSize.Width;
        var height = RenderSize.Height;
   
        //Draw border
        if (!DoubleUtil.IsZero(width) && !DoubleUtil.IsZero(height) && (brush = BorderBrush) != null)
        {
            var useLayoutRounding = UseLayoutRounding;
            var dpi = DpiUtil.GetDpi(this);

            var borders = BorderThickness;
            var borderStyle = BorderStyle;
            var radius = CornerRadius;
            double x, y;

            // Left Line
            if (!DoubleUtil.IsZero(borders.Left))
            {
                if (leftPenCache == null)
                {
                    leftPenCache = GetPen(brush, borderStyle, borders.Left, dpi.DpiScaleX, useLayoutRounding);
                }

                x = leftPenCache.Thickness * 0.5;
                dc.DrawLine(leftPenCache, new Point(x, radius.TopLeft), new Point(x, height - radius.BottomLeft));
            }

            // Top Line
            if (!DoubleUtil.IsZero(borders.Top))
            {
                if (topPenCache == null)
                {
                    topPenCache = GetPen(brush, borderStyle, borders.Top, dpi.DpiScaleY, useLayoutRounding);
                }

                y = topPenCache.Thickness * 0.5;
                dc.DrawLine(topPenCache, new Point(radius.TopLeft, y), new Point(width - radius.TopRight, y));
            }

            // Right Line
            if (!DoubleUtil.IsZero(borders.Right))
            {
                if (rightPenCache == null)
                {
                    rightPenCache = GetPen(brush, borderStyle, borders.Right, dpi.DpiScaleX, useLayoutRounding);
                }

                x =  width - rightPenCache.Thickness * 0.5;
                dc.DrawLine(rightPenCache, new Point(x, radius.TopRight), new Point(x, height - radius.BottomRight));
            }

            // Bottom Line
            if (!DoubleUtil.IsZero(borders.Bottom))
            {
                if (bottomPenCache == null)
                {
                    bottomPenCache = GetPen(brush, borderStyle, borders.Bottom, dpi.DpiScaleY, useLayoutRounding);
                }

                y = height - bottomPenCache.Thickness * 0.5;
                dc.DrawLine(bottomPenCache, new Point(radius.BottomLeft, y), new Point(width - radius.BottomRight, y));
            }

            // Draw Rounded
            Pen pen;

            if (upperLeftCache != null && (pen = GetMaxPen(leftPenCache, topPenCache)) != null)
            {
                dc.DrawGeometry(null, pen, upperLeftCache);
            }

            if (upperRightCache != null && (pen = GetMaxPen(topPenCache, rightPenCache)) != null)
            {
                dc.DrawGeometry(null, pen, upperRightCache);
            }

            if (lowerRightCache != null && (pen = GetMaxPen(rightPenCache, bottomPenCache)) != null)
            {
                dc.DrawGeometry(null, pen, lowerRightCache);
            }

            if (lowerLeftCache != null && (pen = GetMaxPen(bottomPenCache, leftPenCache)) != null)
            {
                dc.DrawGeometry(null, pen, lowerLeftCache);
            }
        }

        // Draw background in rectangle inside border.
        if (backgroundGeometryCache != null && (brush = Background) != null)
        {
            dc.DrawGeometry(brush, null, backgroundGeometryCache);
        }
    }

    private Pen GetMaxPen(Pen pen1, Pen pen2)
    {
        if (pen2 == null || (pen1 != null && pen2.Thickness < pen1.Thickness))
        {
            return pen1;
        }

        return pen2;
    }

    private static StreamGeometry GenerateRoundedGeometry(Point startPoint, Point endPoint, Size size)
    {
        var streamGeometry = new StreamGeometry();

        using (StreamGeometryContext sc = streamGeometry.Open())
        {
            sc.BeginFigure(startPoint, true, false);
            sc.ArcTo(endPoint, size, 0, false, SweepDirection.Clockwise, true, false);
        }

        streamGeometry.Freeze();
        return streamGeometry;
    }

    private static Pen GetPen(Brush brush, BorderStyle borderStyle, double thickness, double dpi, bool useLayoutRounding)
    {
        var pen = new Pen
        {
            Brush = brush,
            DashCap = PenLineCap.Flat,
            Thickness = useLayoutRounding ? UIElementUtil.RoundLayoutValue(thickness, dpi) : thickness,
        };

        switch (borderStyle)
        {
            case BorderStyle.Dotted:
                pen.DashStyle = new DashStyle(new double[] { 1 }, 0d);
                break;
            case BorderStyle.Dashed:
                pen.DashStyle = new DashStyle(new double[] { 4, 2 }, 0d);
                break;
            default:
                break;
        }

        if (brush.IsFrozen)
        {
            pen.Freeze();
        }

        return pen;
    }

    #endregion

    #region Private Structures Classes

    private struct Radii
    {
        #region Fields

        internal readonly Point LeftTop;

        internal readonly Point LeftBottom;

        internal readonly Point TopLeft;

        internal readonly Point TopRight;

        internal readonly Point RightTop;

        internal readonly Point RightBottom;

        internal readonly Point BottomRight;

        internal readonly Point BottomLeft;

        #endregion

        internal Radii(Rect rect, CornerRadius radius, Thickness borders, bool outer)
        {
            var left = borders.Left * 0.5;
            var top = borders.Top * 0.5;
            var right = borders.Right * 0.5;
            var bottom = borders.Bottom * 0.5;

            LeftTop = new Point(0d, 0d);
            LeftBottom = new Point(0d, rect.Height);

            TopLeft = new Point(0d, 0d);
            TopRight = new Point(rect.Width, 0d);

            RightTop = new Point(rect.Width, 0d);
            RightBottom = new Point(rect.Width, rect.Height);

            BottomRight = new Point(rect.Width, rect.Height);
            BottomLeft = new Point(0d, rect.Height);

            if (outer)
            {
                LeftTop.X = left;
                LeftBottom.X = left;

                TopLeft.Y = top;
                TopRight.Y = top;

                RightTop.X -= right;
                RightBottom.X -= right;

                BottomLeft.Y -= bottom;
                BottomRight.Y -= bottom;

                if (!DoubleUtil.IsZero(radius.TopLeft))
                {
                    TopLeft.X = radius.TopLeft; // + left;
                    LeftTop.Y = radius.TopLeft;// + top;
                }

                if (!DoubleUtil.IsZero(radius.TopRight))
                {
                    RightTop.Y = radius.TopRight;// + top;
                    TopRight.X -= radius.TopRight;// + right;
                }
                
                if (!DoubleUtil.IsZero(radius.BottomRight))
                {
                    BottomRight.X -= radius.BottomRight;// + right;
                    RightBottom.Y -= radius.BottomRight;// + bottom; ;
                }

                if (!DoubleUtil.IsZero(radius.BottomLeft))
                {
                    LeftBottom.Y -= radius.BottomLeft; // + bottom;
                    BottomLeft.X = radius.BottomLeft;// + left;
                }
            } else
            {
                TopLeft.X = Math.Max(0.0, radius.TopLeft - left);
                LeftTop.Y = Math.Max(0.0, radius.TopLeft - top);

                RightTop.Y = Math.Max(0.0, radius.TopRight - top);
                TopRight.X -= Math.Max(0.0, radius.TopRight - right);

                BottomRight.X -= Math.Max(0.0, radius.BottomRight - right);
                RightBottom.Y -= Math.Max(0.0, radius.BottomRight - bottom);

                LeftBottom.Y -= Math.Max(0.0, radius.BottomLeft - bottom);
                BottomLeft.X = Math.Max(0.0, radius.BottomLeft - left);
            }

            //  check keypoints for overlap and resolve by partitioning corners according to
            //  the percentage of each one.  

            //  top edge
            if (TopLeft.X > TopRight.X)
            {
                var v = TopLeft.X / (TopLeft.X + rect.Width - TopRight.X) * rect.Width;
                TopLeft.X = v;
                TopRight.X = v;
            }

            //  right edge
            if (RightTop.Y > RightBottom.Y)
            {
                var v = RightTop.Y / (RightTop.Y + rect.Height - RightBottom.Y) * rect.Height;
                RightTop.Y = v;
                RightBottom.Y = v;
            }

            //  bottom edge
            if (BottomRight.X < BottomLeft.X)
            {
                var v = BottomLeft.X / (BottomLeft.X + rect.Width - BottomRight.X) * rect.Width;
                BottomRight.X = v;
                BottomLeft.X = v;
            }

            // left edge
            if (LeftBottom.Y < LeftTop.Y)
            {
                var v = LeftTop.Y / (LeftTop.Y + rect.Height - LeftBottom.Y) * rect.Height;
                LeftBottom.Y = v;
                LeftTop.Y = v;
            }

            // Apply offset
            var offset = new Vector(rect.TopLeft.X, rect.TopLeft.Y);

            LeftTop += offset;
            LeftBottom += offset;

            TopRight += offset;
            TopLeft += offset;

            RightTop += offset;
            RightBottom += offset;

            BottomRight += offset;
            BottomLeft += offset;
        }
    }

    #endregion Private Structures Classes
}