using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Unity.UIWidgets.foundation;
using Unity.UIWidgets.gestures;
using Unity.UIWidgets.painting;
using Unity.UIWidgets.ui;
using UnityEngine;
using Color = Unity.UIWidgets.ui.Color;
using Rect = Unity.UIWidgets.ui.Rect;

namespace Unity.UIWidgets.rendering {
    class _DebugSize : Size {
        internal _DebugSize(Size source, RenderBox _owner, bool _canBeUsedByParent) :
            base(source.width, source.height) {
            this._owner = _owner;
            this._canBeUsedByParent = _canBeUsedByParent;
        }

        internal readonly RenderBox _owner;
        internal readonly bool _canBeUsedByParent;
    }

    public class BoxConstraints : Constraints, IEquatable<BoxConstraints> {
        public BoxConstraints(
            float minWidth = 0.0f,
            float maxWidth = float.PositiveInfinity,
            float minHeight = 0.0f,
            float maxHeight = float.PositiveInfinity) {
            this.minWidth = minWidth;
            this.maxWidth = maxWidth;
            this.minHeight = minHeight;
            this.maxHeight = maxHeight;
        }

        public readonly float minWidth;
        public readonly float maxWidth;
        public readonly float minHeight;
        public readonly float maxHeight;

        public static BoxConstraints tight(Size size) {
            return new BoxConstraints(
                size.width,
                size.width,
                size.height,
                size.height
            );
        }

        public static BoxConstraints tightFor(
            float? width = null,
            float? height = null
        ) {
            return new BoxConstraints(
                width ?? 0.0f,
                width ?? float.PositiveInfinity,
                height ?? 0.0f,
                height ?? float.PositiveInfinity
            );
        }

        public static BoxConstraints tightForFinite(
            float width = float.PositiveInfinity,
            float height = float.PositiveInfinity
        ) {
            return new BoxConstraints(
                !float.IsPositiveInfinity(width) ? width : 0.0f,
                !float.IsPositiveInfinity(width) ? width : float.PositiveInfinity,
                !float.IsPositiveInfinity(height) ? height : 0.0f,
                !float.IsPositiveInfinity(height) ? height : float.PositiveInfinity
            );
        }

        public static BoxConstraints loose(Size size) {
            return new BoxConstraints(
                minWidth: 0,
                maxWidth: size.width,
                minHeight: 0,
                maxHeight: size.height
            );
        }

        public static BoxConstraints expand(
            float? width = null,
            float? height = null
        ) {
            return new BoxConstraints(
                width ?? float.PositiveInfinity,
                width ?? float.PositiveInfinity,
                height ?? float.PositiveInfinity,
                height ?? float.PositiveInfinity
            );
        }

        public BoxConstraints copyWith(
            float? minWidth = null,
            float? maxWidth = null,
            float? minHeight = null,
            float? maxHeight = null
        ) {
            return new BoxConstraints(
                minWidth ?? this.minWidth,
                maxWidth ?? this.maxWidth,
                minHeight ?? this.minHeight,
                maxHeight ?? this.maxHeight
            );
        }

        public BoxConstraints deflate(EdgeInsets edges) {
            D.assert(edges != null);
            D.assert(debugAssertIsValid());
            float horizontal = edges.horizontal;
            float vertical = edges.vertical;
            float deflatedMinWidth = Mathf.Max(0.0f, minWidth - horizontal);
            float deflatedMinHeight = Mathf.Max(0.0f, minHeight - vertical);
            return new BoxConstraints(
                minWidth: deflatedMinWidth,
                maxWidth: Mathf.Max(deflatedMinWidth, maxWidth - horizontal),
                minHeight: deflatedMinHeight,
                maxHeight: Mathf.Max(deflatedMinHeight, maxHeight - vertical)
            );
        }

        public BoxConstraints loosen() {
            D.assert(debugAssertIsValid());
            return new BoxConstraints(
                minWidth: 0.0f,
                maxWidth: maxWidth,
                minHeight: 0.0f,
                maxHeight: maxHeight
            );
        }

        public BoxConstraints enforce(BoxConstraints constraints) {
            return new BoxConstraints(
                minWidth: minWidth.clamp(constraints.minWidth, constraints.maxWidth),
                maxWidth: maxWidth.clamp(constraints.minWidth, constraints.maxWidth),
                minHeight: minHeight.clamp(constraints.minHeight, constraints.maxHeight),
                maxHeight: maxHeight.clamp(constraints.minHeight, constraints.maxHeight)
            );
        }

        public BoxConstraints tighten(
            float? width = null,
            float? height = null
        ) {
            return new BoxConstraints(
                minWidth: width == null ? minWidth : width.Value.clamp(minWidth, maxWidth),
                maxWidth: width == null ? maxWidth : width.Value.clamp(minWidth, maxWidth),
                minHeight: height == null ? minHeight : height.Value.clamp(minHeight, maxHeight),
                maxHeight: height == null ? maxHeight : height.Value.clamp(minHeight, maxHeight)
            );
        }

        public BoxConstraints flipped {
            get {
                return new BoxConstraints(
                    minWidth: minHeight,
                    maxWidth: maxHeight,
                    minHeight: minWidth,
                    maxHeight: maxWidth
                );
            }
        }

        public BoxConstraints widthConstraints() {
            return new BoxConstraints(minWidth: minWidth, maxWidth: maxWidth);
        }

        public BoxConstraints heightConstraints() {
            return new BoxConstraints(minHeight: minHeight, maxHeight: maxHeight);
        }

        public float constrainWidth(float width = float.PositiveInfinity) {
            D.assert(debugAssertIsValid());
            return width.clamp(minWidth, maxWidth);
        }

        public float constrainHeight(float height = float.PositiveInfinity) {
            D.assert(debugAssertIsValid());
            return height.clamp(minHeight, maxHeight);
        }

        Size _debugPropagateDebugSize(Size size, Size result) {
            D.assert(() => {
                if (size is _DebugSize) {
                    result = new _DebugSize(result,
                        ((_DebugSize) size)._owner, ((_DebugSize) size)._canBeUsedByParent);
                }

                return true;
            });
            return result;
        }

        public Size constrain(Size size) {
            var result = new Size(constrainWidth(size.width), constrainHeight(size.height));
            D.assert(() => {
                result = _debugPropagateDebugSize(size, result);
                return true;
            });

            return result;
        }

        public Size constrainDimensions(float width, float height) {
            return new Size(constrainWidth(width), constrainHeight(height));
        }

        public Size constrainSizeAndAttemptToPreserveAspectRatio(Size size) {
            if (isTight) {
                Size result1 = smallest;
                D.assert(() => {
                    result1 = _debugPropagateDebugSize(size, result1);
                    return true;
                });
                return result1;
            }

            float width = size.width;
            float height = size.height;
            D.assert(width > 0.0);
            D.assert(height > 0.0);
            float aspectRatio = width / height;

            if (width > maxWidth) {
                width = maxWidth;
                height = width / aspectRatio;
            }

            if (height > maxHeight) {
                height = maxHeight;
                width = height * aspectRatio;
            }

            if (width < minWidth) {
                width = minWidth;
                height = width / aspectRatio;
            }

            if (height < minHeight) {
                height = minHeight;
                width = height * aspectRatio;
            }

            var result = new Size(constrainWidth(width), constrainHeight(height));
            D.assert(() => {
                result = _debugPropagateDebugSize(size, result);
                return true;
            });
            return result;
        }

        public Size biggest {
            get { return new Size(constrainWidth(), constrainHeight()); }
        }

        public Size smallest {
            get { return new Size(constrainWidth(0.0f), constrainHeight(0.0f)); }
        }

        public bool hasTightWidth {
            get { return minWidth >= maxWidth; }
        }

        public bool hasTightHeight {
            get { return minHeight >= maxHeight; }
        }

        public override bool isTight {
            get { return hasTightWidth && hasTightHeight; }
        }

        public bool hasBoundedWidth {
            get { return maxWidth < float.PositiveInfinity; }
        }

        public bool hasBoundedHeight {
            get { return maxHeight < float.PositiveInfinity; }
        }

        public bool hasInfiniteWidth {
            get { return minWidth >= float.PositiveInfinity; }
        }

        public bool hasInfiniteHeight {
            get { return minHeight >= float.PositiveInfinity; }
        }

        public bool isSatisfiedBy(Size size) {
            D.assert(debugAssertIsValid());
            return minWidth <= size.width && size.width <= maxWidth &&
                   minHeight <= size.height && size.height <= maxHeight;
        }

        public static BoxConstraints operator *(BoxConstraints it, float factor) {
            return new BoxConstraints(
                minWidth: it.minWidth * factor,
                maxWidth: it.maxWidth * factor,
                minHeight: it.minHeight * factor,
                maxHeight: it.maxHeight * factor
            );
        }

        public static BoxConstraints operator /(BoxConstraints it, float factor) {
            return new BoxConstraints(
                minWidth: it.minWidth / factor,
                maxWidth: it.maxWidth / factor,
                minHeight: it.minHeight / factor,
                maxHeight: it.maxHeight / factor
            );
        }

        public static BoxConstraints operator %(BoxConstraints it, float value) {
            return new BoxConstraints(
                minWidth: it.minWidth % value,
                maxWidth: it.maxWidth % value,
                minHeight: it.minHeight % value,
                maxHeight: it.maxHeight % value
            );
        }

        public static BoxConstraints lerp(BoxConstraints a, BoxConstraints b, float t) {
            if (a == null && b == null) {
                return null;
            }

            if (a == null) {
                return b * t;
            }

            if (b == null) {
                return a * (1.0f - t);
            }

            D.assert(a.debugAssertIsValid());
            D.assert(b.debugAssertIsValid());
            D.assert(
                (a.minWidth.isFinite() && b.minWidth.isFinite()) ||
                (a.minWidth == float.PositiveInfinity && b.minWidth == float.PositiveInfinity),
                () => "Cannot interpolate between finite constraints and unbounded constraints.");
            D.assert(
                (a.maxWidth.isFinite() && b.maxWidth.isFinite()) ||
                (a.maxWidth == float.PositiveInfinity && b.maxWidth == float.PositiveInfinity),
                () => "Cannot interpolate between finite constraints and unbounded constraints.");
            D.assert(
                (a.minHeight.isFinite() && b.minHeight.isFinite()) ||
                (a.minHeight == float.PositiveInfinity && b.minHeight == float.PositiveInfinity),
                () => "Cannot interpolate between finite constraints and unbounded constraints.");
            D.assert(
                (a.maxHeight.isFinite() && b.maxHeight.isFinite()) ||
                (a.maxHeight == float.PositiveInfinity && b.maxHeight == float.PositiveInfinity),
                () => "Cannot interpolate between finite constraints and unbounded constraints.");
            return new BoxConstraints(
                minWidth: a.minWidth.isFinite()
                    ? MathUtils.lerpFloat(a.minWidth, b.minWidth, t)
                    : float.PositiveInfinity,
                maxWidth: a.maxWidth.isFinite()
                    ? MathUtils.lerpFloat(a.maxWidth, b.maxWidth, t)
                    : float.PositiveInfinity,
                minHeight: a.minHeight.isFinite()
                    ? MathUtils.lerpFloat(a.minHeight, b.minHeight, t)
                    : float.PositiveInfinity,
                maxHeight: a.maxHeight.isFinite()
                    ? MathUtils.lerpFloat(a.maxHeight, b.maxHeight, t)
                    : float.PositiveInfinity
            );
        }

        public override bool isNormalized {
            get {
                return minWidth >= 0.0 &&
                       minWidth <= maxWidth &&
                       minHeight >= 0.0 &&
                       minHeight <= maxHeight;
            }
        }

        public override bool debugAssertIsValid(
            bool isAppliedConstraint = false,
            InformationCollector informationCollector = null
        ) {
            D.assert(() => {
                var throwError = new Action<string>(message => {
                    var information = new StringBuilder();
                    if (informationCollector != null) {
                        informationCollector(information);
                    }

                    throw new UIWidgetsError($"{message}\n{information}The offending constraints were:\n  {this}");
                });

                if (minWidth.isNaN() ||
                    maxWidth.isNaN() ||
                    minHeight.isNaN() ||
                    maxHeight.isNaN()) {
                    var affectedFieldsList = new List<string>();
                    if (minWidth.isNaN()) {
                        affectedFieldsList.Add("minWidth");
                    }

                    if (maxWidth.isNaN()) {
                        affectedFieldsList.Add("maxWidth");
                    }

                    if (minHeight.isNaN()) {
                        affectedFieldsList.Add("minHeight");
                    }

                    if (maxHeight.isNaN()) {
                        affectedFieldsList.Add("maxHeight");
                    }

                    D.assert(affectedFieldsList.isNotEmpty());
                    if (affectedFieldsList.Count > 1) {
                        var last = affectedFieldsList.Last();
                        affectedFieldsList.RemoveAt(affectedFieldsList.Count - 1);
                        affectedFieldsList.Add("and " + last);
                    }

                    string whichFields;
                    if (affectedFieldsList.Count > 2) {
                        whichFields = string.Join(", ", affectedFieldsList.ToArray());
                    }
                    else if (affectedFieldsList.Count == 2) {
                        whichFields = string.Join(" ", affectedFieldsList.ToArray());
                    }
                    else {
                        whichFields = affectedFieldsList.Single();
                    }

                    throwError("BoxConstraints has NaN values in " + whichFields + ".");
                }

                if (minWidth < 0.0 && minHeight < 0.0) {
                    throwError("BoxConstraints has both a negative minimum width and a negative minimum height.");
                }

                if (minWidth < 0.0) {
                    throwError("BoxConstraints has a negative minimum width.");
                }

                if (minHeight < 0.0) {
                    throwError("BoxConstraints has a negative minimum height.");
                }

                if (maxWidth < minWidth && maxHeight < minHeight) {
                    throwError("BoxConstraints has both width and height constraints non-normalized.");
                }

                if (maxWidth < minWidth) {
                    throwError("BoxConstraints has non-normalized width constraints.");
                }

                if (maxHeight < minHeight) {
                    throwError("BoxConstraints has non-normalized height constraints.");
                }

                if (isAppliedConstraint) {
                    if (minWidth.isInfinite() && minHeight.isInfinite()) {
                        throwError("BoxConstraints forces an infinite width and infinite height.");
                    }

                    if (minWidth.isInfinite()) {
                        throwError("BoxConstraints forces an infinite width.");
                    }

                    if (minHeight.isInfinite()) {
                        throwError("BoxConstraints forces an infinite height.");
                    }
                }

                D.assert(isNormalized);
                return true;
            });
            return isNormalized;
        }

        public BoxConstraints normalize() {
            if (isNormalized) {
                return this;
            }

            var minWidth = this.minWidth >= 0.0 ? this.minWidth : 0.0f;
            var minHeight = this.minHeight >= 0.0 ? this.minHeight : 0.0f;

            return new BoxConstraints(
                minWidth,
                minWidth > maxWidth ? minWidth : maxWidth,
                minHeight,
                minHeight > maxHeight ? minHeight : maxHeight
            );
        }

        public bool Equals(BoxConstraints other) {
            if (ReferenceEquals(null, other)) {
                return false;
            }

            if (ReferenceEquals(this, other)) {
                return true;
            }

            return minWidth.Equals(other.minWidth)
                   && maxWidth.Equals(other.maxWidth)
                   && minHeight.Equals(other.minHeight)
                   && maxHeight.Equals(other.maxHeight);
        }

        public override bool Equals(object obj) {
            if (ReferenceEquals(null, obj)) {
                return false;
            }

            if (ReferenceEquals(this, obj)) {
                return true;
            }

            if (obj.GetType() != GetType()) {
                return false;
            }

            return Equals((BoxConstraints) obj);
        }

        public override int GetHashCode() {
            unchecked {
                var hashCode = minWidth.GetHashCode();
                hashCode = (hashCode * 397) ^ maxWidth.GetHashCode();
                hashCode = (hashCode * 397) ^ minHeight.GetHashCode();
                hashCode = (hashCode * 397) ^ maxHeight.GetHashCode();
                return hashCode;
            }
        }

        public static bool operator ==(BoxConstraints left, BoxConstraints right) {
            return Equals(left, right);
        }

        public static bool operator !=(BoxConstraints left, BoxConstraints right) {
            return !Equals(left, right);
        }

        public override string ToString() {
            string annotation = isNormalized ? "" : "; NOT NORMALIZED";
            if (minWidth == float.PositiveInfinity &&
                minHeight == float.PositiveInfinity) {
                return "BoxConstraints(biggest" + annotation + ")";
            }

            if (minWidth == 0 && maxWidth == float.PositiveInfinity &&
                minHeight == 0 && maxHeight == float.PositiveInfinity) {
                return "BoxConstraints(unconstrained" + annotation + ")";
            }

            var describe = new Func<float, float, string, string>((min, max, dim) => {
                if (min == max) {
                    return dim + "=" + min.ToString("F1");
                }

                return min.ToString("F1") + "<=" + dim + "<=" + max.ToString("F1");
            });

            string width = describe(minWidth, maxWidth, "w");
            string height = describe(minHeight, maxHeight, "h");
            return "BoxConstraints(" + width + ", " + height + annotation + ")";
        }
    }

    public class BoxHitTestEntry : HitTestEntry {
        public BoxHitTestEntry(RenderBox target, Offset localPosition)
            : base(target) {
            D.assert(localPosition != null);
            this.localPosition = localPosition;
        }

        public new RenderBox target {
            get { return (RenderBox) base.target; }
        }

        public readonly Offset localPosition;

        public override string ToString() {
            return $"{foundation_.describeIdentity(target)}@{localPosition}";
        }
    }

    public delegate bool BoxHitTest(BoxHitTestResult result, Offset position);

    public class BoxHitTestResult : HitTestResult {
        public BoxHitTestResult() : base() {
        }

        public BoxHitTestResult(HitTestResult result) : base(result) {
        }

        public bool addWithPaintTransform(
            Matrix4 transform,
            Offset position,
            BoxHitTest hitTest
        ) {
            D.assert(hitTest != null);
            if (transform != null) {
                transform = Matrix4.tryInvert(PointerEvent.removePerspectiveTransform(transform));
                if (transform == null) {
                    // Objects are not visible on screen and cannot be hit-tested.
                    return false;
                }
            }

            return addWithRawTransform(
                transform: transform,
                position: position,
                hitTest: hitTest
            );
        }

        public bool addWithPaintOffset(
            Offset offset,
            Offset position,
            BoxHitTest hitTest
        ) {
            D.assert(hitTest != null);
            return addWithRawTransform(
                transform: offset != null ? new Matrix4().translationValues(-offset.dx, -offset.dy, 0) : null,
                position: position,
                hitTest: hitTest
            );
        }

        public bool addWithRawTransform(
            Matrix4 transform,
            Offset position,
            BoxHitTest hitTest
        ) {
            D.assert(hitTest != null);
            Offset transformedPosition = position == null || transform == null
                ? position
                : MatrixUtils.transformPoint(transform, position);
            if (transform != null) {
                pushTransform(transform);
            }

            bool isHit = hitTest(this, transformedPosition);
            if (transform != null) {
                popTransform();
            }

            return isHit;
        }
    }

    public class BoxParentData : ParentData {
        public Offset offset {
            get { return _offset; }
            set { _offset = value; }
        }

        Offset _offset = Offset.zero;

        public override string ToString() {
            return "offset=" + offset;
        }
    }

    enum _IntrinsicDimension {
        minWidth,
        maxWidth,
        minHeight,
        maxHeight
    }

    class _IntrinsicDimensionsCacheEntry : IEquatable<_IntrinsicDimensionsCacheEntry> {
        internal _IntrinsicDimensionsCacheEntry(_IntrinsicDimension dimension, float argument) {
            this.dimension = dimension;
            this.argument = argument;
        }

        public readonly _IntrinsicDimension dimension;
        public readonly float argument;

        public bool Equals(_IntrinsicDimensionsCacheEntry other) {
            if (ReferenceEquals(null, other)) {
                return false;
            }

            if (ReferenceEquals(this, other)) {
                return true;
            }

            return dimension == other.dimension && argument.Equals(other.argument);
        }

        public override bool Equals(object obj) {
            if (ReferenceEquals(null, obj)) {
                return false;
            }

            if (ReferenceEquals(this, obj)) {
                return true;
            }

            if (obj.GetType() != GetType()) {
                return false;
            }

            return Equals((_IntrinsicDimensionsCacheEntry) obj);
        }

        public override int GetHashCode() {
            unchecked {
                return ((int) dimension * 397) ^ argument.GetHashCode();
            }
        }

        public static bool operator ==(_IntrinsicDimensionsCacheEntry a, _IntrinsicDimensionsCacheEntry b) {
            return Equals(a, b);
        }

        public static bool operator !=(_IntrinsicDimensionsCacheEntry a, _IntrinsicDimensionsCacheEntry b) {
            return !Equals(a, b);
        }
    }

    public abstract class RenderBox : RenderObject {
        public override void setupParentData(RenderObject child) {
            if (!(child.parentData is BoxParentData)) {
                child.parentData = new BoxParentData();
            }
        }

        Dictionary<_IntrinsicDimensionsCacheEntry, float> _cachedIntrinsicDimensions;

        float _computeIntrinsicDimension(_IntrinsicDimension dimension, float argument,
            Func<float, float> computer) {
            D.assert(debugCheckingIntrinsics || !debugDoingThisResize);
            bool shouldCache = true;
            D.assert(() => {
                if (debugCheckingIntrinsics) {
                    shouldCache = false;
                }

                return true;
            });

            if (shouldCache) {
                _cachedIntrinsicDimensions =
                    _cachedIntrinsicDimensions
                    ?? new Dictionary<_IntrinsicDimensionsCacheEntry, float>();
                return _cachedIntrinsicDimensions.putIfAbsent(
                    new _IntrinsicDimensionsCacheEntry(dimension, argument),
                    () => computer(argument));
            }

            return computer(argument);
        }

        public float getMinIntrinsicWidth(float height) {
            D.assert(() => {
                if (height < 0.0) {
                    throw new UIWidgetsError(
                        "The height argument to getMinIntrinsicWidth was negative.\n" +
                        "The argument to getMinIntrinsicWidth must not be negative. " +
                        "If you perform computations on another height before passing it to " +
                        "getMinIntrinsicWidth, consider using Mathf.Max() or float.clamp() " +
                        "to force the value into the valid range."
                    );
                }

                return true;
            });

            return _computeIntrinsicDimension(_IntrinsicDimension.minWidth, height, computeMinIntrinsicWidth);
        }

        protected virtual float computeMinIntrinsicWidth(float height) {
            return 0.0f;
        }

        public float getMaxIntrinsicWidth(float height) {
            D.assert(() => {
                if (height < 0.0) {
                    throw new UIWidgetsError(
                        "The height argument to getMaxIntrinsicWidth was negative.\n" +
                        "The argument to getMaxIntrinsicWidth must not be negative. " +
                        "If you perform computations on another height before passing it to " +
                        "getMaxIntrinsicWidth, consider using Mathf.Max() or float.clamp() " +
                        "to force the value into the valid range."
                    );
                }

                return true;
            });

            return _computeIntrinsicDimension(_IntrinsicDimension.maxWidth, height, computeMaxIntrinsicWidth);
        }

        protected virtual float computeMaxIntrinsicWidth(float height) {
            return 0.0f;
        }

        public float getMinIntrinsicHeight(float width) {
            D.assert(() => {
                if (width < 0.0) {
                    throw new UIWidgetsError(
                        "The width argument to getMinIntrinsicHeight was negative.\n" +
                        "The argument to getMinIntrinsicHeight must not be negative. " +
                        "If you perform computations on another width before passing it to " +
                        "getMinIntrinsicHeight, consider using Mathf.Max() or float.clamp() " +
                        "to force the value into the valid range."
                    );
                }

                return true;
            });

            return _computeIntrinsicDimension(_IntrinsicDimension.minHeight, width,
                computeMinIntrinsicHeight);
        }

        protected virtual float computeMinIntrinsicHeight(float width) {
            return 0.0f;
        }

        public float getMaxIntrinsicHeight(float width) {
            D.assert(() => {
                if (width < 0.0) {
                    throw new UIWidgetsError(
                        "The width argument to getMaxIntrinsicHeight was negative.\n" +
                        "The argument to getMaxIntrinsicHeight must not be negative. " +
                        "If you perform computations on another width before passing it to " +
                        "getMaxIntrinsicHeight, consider using Mathf.Max() or float.clamp() " +
                        "to force the value into the valid range."
                    );
                }

                return true;
            });

            return _computeIntrinsicDimension(_IntrinsicDimension.maxHeight, width,
                computeMaxIntrinsicHeight);
        }

        protected internal virtual float computeMaxIntrinsicHeight(float width) {
            return 0.0f;
        }

        public bool hasSize {
            get { return _size != null; }
        }

        public Size size {
            get {
                D.assert(hasSize, () => "RenderBox was not laid out: " + this);
                D.assert(() => {
                    if (this._size is _DebugSize) {
                        _DebugSize _size = (_DebugSize) this._size;
                        D.assert(_size._owner == this);
                        if (debugActiveLayout != null) {
                            D.assert(debugDoingThisResize || debugDoingThisLayout ||
                                     (debugActiveLayout == parent && _size._canBeUsedByParent));
                        }

                        D.assert(_size == this._size);
                    }

                    return true;
                });

                return this._size;
            }
            set {
                D.assert(!(debugDoingThisResize && debugDoingThisLayout));
                D.assert(sizedByParent || !debugDoingThisResize);
                D.assert(() => {
                    if ((sizedByParent && debugDoingThisResize) ||
                        (!sizedByParent && debugDoingThisLayout)) {
                        return true;
                    }

                    D.assert(!debugDoingThisResize);

                    string contract = "", violation = "", hint = "";
                    if (debugDoingThisLayout) {
                        D.assert(sizedByParent);
                        violation = "It appears that the size setter was called from performLayout().";
                        hint = "";
                    }
                    else {
                        violation =
                            "The size setter was called from outside layout (neither performResize() nor performLayout() were being run for this object).";
                        if (owner != null && owner.debugDoingLayout) {
                            hint =
                                "Only the object itself can set its size. It is a contract violation for other objects to set it.";
                        }
                    }

                    if (sizedByParent) {
                        contract =
                            "Because this RenderBox has sizedByParent set to true, it must set its size in performResize().";
                    }
                    else {
                        contract =
                            "Because this RenderBox has sizedByParent set to false, it must set its size in performLayout().";
                    }

                    throw new UIWidgetsError(
                        "RenderBox size setter called incorrectly.\n" +
                        violation + "\n" +
                        hint + "\n" +
                        contract + "\n" +
                        "The RenderBox in question is:\n" +
                        "  " + this
                    );
                });
                D.assert(() => {
                    value = debugAdoptSize(value);
                    return true;
                });

                _size = value;

                D.assert(() => {
                    debugAssertDoesMeetConstraints();
                    return true;
                });
            }
        }

        Size _size;

        public Size debugAdoptSize(Size valueRaw) {
            Size result = valueRaw;
            D.assert(() => {
                if (valueRaw is _DebugSize) {
                    var value = (_DebugSize) valueRaw;
                    if (value._owner != this) {
                        if (value._owner.parent != this) {
                            throw new UIWidgetsError(
                                "The size property was assigned a size inappropriately.\n" +
                                "The following render object:\n" +
                                "  " + this + "\n" +
                                "...was assigned a size obtained from:\n" +
                                "  " + value._owner + "\n" +
                                "However, this second render object is not, or is no longer, a " +
                                "child of the first, and it is therefore a violation of the " +
                                "RenderBox layout protocol to use that size in the layout of the " +
                                "first render object.\n" +
                                "If the size was obtained at a time where it was valid to read " +
                                "the size (because the second render object above was a child " +
                                "of the first at the time), then it should be adopted using " +
                                "debugAdoptSize at that time.\n" +
                                "If the size comes from a grandchild or a render object from an " +
                                "entirely different part of the render tree, then there is no " +
                                "way to be notified when the size changes and therefore attempts " +
                                "to read that size are almost certainly a source of bugs. A different " +
                                "approach should be used."
                            );
                        }

                        if (!value._canBeUsedByParent) {
                            throw new UIWidgetsError(
                                "A child\"s size was used without setting parentUsesSize.\n" +
                                "The following render object:\n" +
                                "  " + this + "\n" +
                                "...was assigned a size obtained from its child:\n" +
                                "  " + value._owner + "\n" +
                                "However, when the child was laid out, the parentUsesSize argument " +
                                "was not set or set to false. Subsequently this transpired to be " +
                                "inaccurate: the size was nonetheless used by the parent.\n" +
                                "It is important to tell the framework if the size will be used or not " +
                                "as several important performance optimizations can be made if the " +
                                "size will not be used by the parent."
                            );
                        }
                    }
                }

                result = new _DebugSize(valueRaw, this, debugCanParentUseSize);
                return true;
            });
            return result;
        }

        public override Rect semanticBounds {
            get { return Offset.zero & size; }
        }

        protected override void debugResetSize() {
            size = size;
        }

        Dictionary<TextBaseline, float?> _cachedBaselines;
        static bool _debugDoingBaseline = false;

        static bool _debugSetDoingBaseline(bool value) {
            _debugDoingBaseline = value;
            return true;
        }

        public float? getDistanceToBaseline(TextBaseline baseline, bool onlyReal = false) {
            D.assert(!_debugDoingBaseline,
                () =>
                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
            D.assert(!debugNeedsLayout);
            D.assert(() => {
                RenderObject parent = (RenderObject) this.parent;
                if (owner.debugDoingLayout) {
                    return (debugActiveLayout == parent) && parent.debugDoingThisLayout;
                }

                if (owner.debugDoingPaint) {
                    return ((debugActivePaint == parent) && parent.debugDoingThisPaint) ||
                           ((debugActivePaint == this) && debugDoingThisPaint);
                }

                D.assert(parent == this.parent);
                return false;
            });

            D.assert(_debugSetDoingBaseline(true));
            float? result = getDistanceToActualBaseline(baseline);
            D.assert(_debugSetDoingBaseline(false));

            if (result == null && !onlyReal) {
                return size.height;
            }

            return result;
        }

        public virtual float? getDistanceToActualBaseline(TextBaseline baseline) {
            D.assert(_debugDoingBaseline,
                () =>
                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");

            _cachedBaselines = _cachedBaselines ?? new Dictionary<TextBaseline, float?>();
            return _cachedBaselines.putIfAbsent(baseline, () => computeDistanceToActualBaseline(baseline));
        }

        protected virtual float? computeDistanceToActualBaseline(TextBaseline baseline) {
            D.assert(_debugDoingBaseline,
                () =>
                    "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");

            return null;
        }

        public new BoxConstraints constraints {
            get { return (BoxConstraints) base.constraints; }
        }

        protected override void debugAssertDoesMeetConstraints() {
            D.assert(constraints != null);
            D.assert(() => {
                if (!hasSize) {
                    D.assert(!debugNeedsLayout);
                    string contract = "";
                    if (sizedByParent) {
                        contract =
                            "Because this RenderBox has sizedByParent set to true, it must set its size in performResize().\n";
                    }
                    else {
                        contract =
                            "Because this RenderBox has sizedByParent set to false, it must set its size in performLayout().\n";
                    }

                    throw new UIWidgetsError(
                        "RenderBox did not set its size during layout.\n" +
                        contract +
                        "It appears that this did not happen; layout completed, but the size property is still null.\n" +
                        "The RenderBox in question is:\n" +
                        "  " + this);
                }

                if (!_size.isFinite) {
                    var information = new StringBuilder();
                    if (!constraints.hasBoundedWidth) {
                        RenderBox node = this;
                        while (!node.constraints.hasBoundedWidth && node.parent is RenderBox) {
                            node = (RenderBox) node.parent;
                        }

                        information.AppendLine("The nearest ancestor providing an unbounded width constraint is:");
                        information.Append("  ");
                        information.AppendLine(node.toStringShallow(joiner: "\n  "));
                    }

                    if (!constraints.hasBoundedHeight) {
                        RenderBox node = this;
                        while (!node.constraints.hasBoundedHeight && node.parent is RenderBox) {
                            node = (RenderBox) node.parent;
                        }

                        information.AppendLine("The nearest ancestor providing an unbounded height constraint is:");
                        information.Append("  ");
                        information.AppendLine(node.toStringShallow(joiner: "\n  "));
                    }

                    throw new UIWidgetsError(
                        GetType() + " object was given an infinite size during layout.\n" +
                        "This probably means that it is a render object that tries to be " +
                        "as big as possible, but it was put inside another render object " +
                        "that allows its children to pick their own size.\n" +
                        information +
                        "The constraints that applied to the " + GetType() + " were:\n" +
                        "  " + constraints + "\n" +
                        "The exact size it was given was:\n" +
                        "  " + _size
                    );
                }

                if (!constraints.isSatisfiedBy(_size)) {
                    throw new UIWidgetsError(
                        GetType() + " does not meet its constraints.\n" +
                        "Constraints: " + constraints + "\n" +
                        "Size: " + _size + "\n" +
                        "If you are not writing your own RenderBox subclass, then this is not " +
                        "your fault."
                    );
                }

                if (D.debugCheckIntrinsicSizes) {
                    D.assert(!debugCheckingIntrinsics);
                    debugCheckingIntrinsics = true;
                    var failures = new StringBuilder();
                    int failureCount = 0;

                    var testIntrinsic = new Func<Func<float, float>, string, float, float>(
                        (function, name, constraint) => {
                            float result = function(constraint);
                            if (result < 0) {
                                failures.AppendLine(" * " + name + "(" + constraint + ") returned a negative value: " +
                                                    result);
                                failureCount += 1;
                            }

                            if (result.isInfinite()) {
                                failures.AppendLine(" * " + name + "(" + constraint +
                                                    ") returned a non-finite value: " + result);
                                failureCount += 1;
                            }

                            return result;
                        });

                    var testIntrinsicsForValues =
                        new Action<Func<float, float>, Func<float, float>, string, float>(
                            (getMin, getMax, name, constraint) => {
                                float min = testIntrinsic(getMin, "getMinIntrinsic" + name, constraint);
                                float max = testIntrinsic(getMax, "getMaxIntrinsic" + name, constraint);
                                if (min > max) {
                                    failures.AppendLine(
                                        " * getMinIntrinsic" + name + "(" + constraint + ") returned a larger value (" +
                                        min +
                                        ") than getMaxIntrinsic" + name + "(" + constraint + ") (" + max + ")");
                                    failureCount += 1;
                                }
                            });

                    testIntrinsicsForValues(getMinIntrinsicWidth, getMaxIntrinsicWidth, "Width",
                        float.PositiveInfinity);
                    testIntrinsicsForValues(getMinIntrinsicHeight, getMaxIntrinsicHeight, "Height",
                        float.PositiveInfinity);

                    if (constraints.hasBoundedWidth) {
                        testIntrinsicsForValues(getMinIntrinsicWidth, getMaxIntrinsicWidth, "Width",
                            constraints.maxHeight);
                    }

                    if (constraints.hasBoundedHeight) {
                        testIntrinsicsForValues(getMinIntrinsicHeight, getMaxIntrinsicHeight, "Height",
                            constraints.maxWidth);
                    }

                    debugCheckingIntrinsics = false;
                    if (failures.Length > 0) {
                        D.assert(failureCount > 0);
                        throw new UIWidgetsError(
                            "The intrinsic dimension methods of the " + GetType() +
                            " class returned values that violate the intrinsic protocol contract.\n" +
                            "The following failures was detected:\n" +
                            failures +
                            "If you are not writing your own RenderBox subclass, then this is not\n" +
                            "your fault."
                        );
                    }
                }

                return true;
            });
        }

        public override void markNeedsLayout() {
            if (_cachedBaselines != null && _cachedBaselines.isNotEmpty() ||
                _cachedIntrinsicDimensions != null && _cachedIntrinsicDimensions.isNotEmpty()) {
                if (_cachedBaselines != null) {
                    _cachedBaselines.Clear();
                }

                if (_cachedIntrinsicDimensions != null) {
                    _cachedIntrinsicDimensions.Clear();
                }

                if (parent is RenderObject) {
                    markParentNeedsLayout();
                    return;
                }
            }

            base.markNeedsLayout();
        }


        protected override void performResize() {
            size = constraints.smallest;
            D.assert(size.isFinite);
        }

        protected override void performLayout() {
            D.assert(() => {
                if (!sizedByParent) {
                    throw new UIWidgetsError(
                        GetType() + " did not implement performLayout().\n" +
                        "RenderBox subclasses need to either override performLayout() to " +
                        "set a size and lay out any children, or, set sizedByParent to true " +
                        "so that performResize() sizes the render object."
                    );
                }

                return true;
            });
        }

        public virtual bool hitTest(BoxHitTestResult result, Offset position = null) {
            D.assert(position != null);
            D.assert(() => {
                if (!hasSize) {
                    if (debugNeedsLayout) {
                        throw new UIWidgetsError(
                            "Cannot hit test a render box that has never been laid out.\n" +
                            "The hitTest() method was called on this RenderBox:\n" +
                            "  " + this + "\n" +
                            "Unfortunately, this object\"s geometry is not known at this time, " +
                            "probably because it has never been laid out. " +
                            "This means it cannot be accurately hit-tested. If you are trying " +
                            "to perform a hit test during the layout phase itself, make sure " +
                            "you only hit test nodes that have completed layout (e.g. the node\"s " +
                            "children, after their layout() method has been called)."
                        );
                    }

                    throw new UIWidgetsError(
                        "Cannot hit test a render box with no size.\n" +
                        "The hitTest() method was called on this RenderBox:\n" +
                        "  " + this + "\n" +
                        "Although this node is not marked as needing layout, " +
                        "its size is not set. A RenderBox object must have an " +
                        "explicit size before it can be hit-tested. Make sure " +
                        "that the RenderBox in question sets its size during layout."
                    );
                }

                return true;
            });

            if (_size.contains(position)) {
                if (hitTestChildren(result, position: position) || hitTestSelf(position)) {
                    result.add(new BoxHitTestEntry(this, position));
                    return true;
                }
            }

            return false;
        }

        protected virtual bool hitTestSelf(Offset position) {
            return false;
        }

        protected virtual bool hitTestChildren(BoxHitTestResult result, Offset position = null) {
            return false;
        }

        public override void applyPaintTransform(RenderObject child, Matrix4 transform) {
            D.assert(child != null);
            D.assert(child.parent == this);
            D.assert(() => {
                if (!(child.parentData is BoxParentData)) {
                    throw new UIWidgetsError(
                        GetType() + " does not implement applyPaintTransform.\n" +
                        "The following " + GetType() + " object:\n" +
                        "  " + toStringShallow() + "\n" +
                        "...did not use a BoxParentData class for the parentData field of the following child:\n" +
                        "  " + child.toStringShallow() + "\n" +
                        "The " + GetType() + " class inherits from RenderBox. " +
                        "The default applyPaintTransform implementation provided by RenderBox assumes that the " +
                        "children all use BoxParentData objects for their parentData field. " +
                        "Since " + GetType() +
                        " does not in fact use that ParentData class for its children, it must " +
                        "provide an implementation of applyPaintTransform that supports the specific ParentData " +
                        "subclass used by its children (which apparently is " + child.parentData.GetType() + ")."
                    );
                }

                return true;
            });

            var childParentData = (BoxParentData) child.parentData;
            var offset = childParentData.offset;
            transform.translate(offset.dx, offset.dy);
        }

        public Offset globalToLocal(Offset point, RenderObject ancestor = null) {
            var transform = getTransformTo(ancestor);
            float det = transform.invert();
            if (det == 0) {
                return Offset.zero;
            }

            Vector3 n = new Vector3(0, 0, 1);
            Vector3 i = transform.perspectiveTransform(new Vector3(0, 0, 0));
            Vector3 d = transform.perspectiveTransform(new Vector3(0, 0, 1)) - i;
            Vector3 s = transform.perspectiveTransform(new Vector3(point.dx, point.dy, 0));
            Vector3 p = s - d * (n.dot(s) / n.dot(d));
            return new Offset(p.x, p.y);
        }

        public Offset localToGlobal(Offset point, RenderObject ancestor = null) {
            return MatrixUtils.transformPoint(getTransformTo(ancestor), point);
        }

        public override Rect paintBounds {
            get { return Offset.zero & size; }
        }

        int _debugActivePointers = 0;

        protected bool debugHandleEvent(PointerEvent evt, HitTestEntry entry) {
            D.assert(() => {
                if (D.debugPaintPointersEnabled) {
                    if (evt is PointerDownEvent) {
                        _debugActivePointers += 1;
                    }
                    else if (evt is PointerUpEvent || evt is PointerCancelEvent) {
                        _debugActivePointers -= 1;
                    }

                    markNeedsPaint();
                }

                return true;
            });
            return true;
        }

        public override void debugPaint(PaintingContext context, Offset offset) {
            D.assert(() => {
                if (D.debugPaintSizeEnabled) {
                    debugPaintSize(context, offset);
                }

                if (D.debugPaintBaselinesEnabled) {
                    debugPaintBaselines(context, offset);
                }

                if (D.debugPaintPointersEnabled) {
                    debugPaintPointers(context, offset);
                }

                return true;
            });
        }

        protected virtual void debugPaintSize(PaintingContext context, Offset offset) {
            D.assert(() => {
                var paint = new Paint {
                    color = new Color(0xFF00FFFF),
                    strokeWidth = 1,
                    style = PaintingStyle.stroke,
                };
                context.canvas.drawRect((offset & size).deflate(0.5f), paint);
                return true;
            });
        }

        protected virtual void debugPaintBaselines(PaintingContext context, Offset offset) {
            D.assert(() => {
                Paint paint = new Paint {
                    style = PaintingStyle.stroke,
                    strokeWidth = 0.25f
                };

                Path path;
                // ideographic baseline
                float? baselineI = getDistanceToBaseline(TextBaseline.ideographic, onlyReal: true);
                if (baselineI != null) {
                    paint.color = new Color(0xFFFFD000);
                    path = new Path();
                    path.moveTo(offset.dx, offset.dy + baselineI.Value);
                    path.lineTo(offset.dx + size.width, offset.dy + baselineI.Value);
                    context.canvas.drawPath(path, paint);
                }

                // alphabetic baseline
                float? baselineA = getDistanceToBaseline(TextBaseline.alphabetic, onlyReal: true);
                if (baselineA != null) {
                    paint.color = new Color(0xFF00FF00);
                    path = new Path();
                    path.moveTo(offset.dx, offset.dy + baselineA.Value);
                    path.lineTo(offset.dx + size.width, offset.dy + baselineA.Value);
                    context.canvas.drawPath(path, paint);
                }

                return true;
            });
        }

        protected virtual void debugPaintPointers(PaintingContext context, Offset offset) {
            D.assert(() => {
                if (_debugActivePointers > 0) {
                    var paint = new Paint {
                        color = new Color(0x00BBBB | ((0x04000000 * depth) & 0xFF000000)),
                    };
                    context.canvas.drawRect(offset & size, paint);
                }

                return true;
            });
        }

        public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
            base.debugFillProperties(properties);
            properties.add(new DiagnosticsProperty<Size>("size", _size, missingIfNull: true));
        }
    }

    public abstract class ContainerBoxParentData<ChildType> : ContainerParentDataMixinBoxParentData<ChildType>
        where ChildType : RenderBox {
    }

    public abstract class
        RenderBoxContainerDefaultsMixin<ChildType, ParentDataType>
        : ContainerRenderObjectMixinRenderBox<ChildType, ParentDataType>
        where ChildType : RenderBox
        where ParentDataType : ContainerParentDataMixinBoxParentData<ChildType> {
        public float? defaultComputeDistanceToFirstActualBaseline(TextBaseline baseline) {
            D.assert(!debugNeedsLayout);

            var child = firstChild;
            while (child != null) {
                var childParentData = (ParentDataType) child.parentData;
                float? result = child.getDistanceToActualBaseline(baseline);
                if (result != null) {
                    return result.Value + childParentData.offset.dy;
                }

                child = childParentData.nextSibling;
            }

            return null;
        }

        public float? defaultComputeDistanceToHighestActualBaseline(TextBaseline baseline) {
            D.assert(!debugNeedsLayout);

            float? result = null;
            var child = firstChild;
            while (child != null) {
                var childParentData = (ParentDataType) child.parentData;
                float? candidate = child.getDistanceToActualBaseline(baseline);
                if (candidate != null) {
                    candidate += childParentData.offset.dy;
                    if (result != null) {
                        result = Mathf.Min(result.Value, candidate.Value);
                    }
                    else {
                        result = candidate;
                    }
                }

                child = childParentData.nextSibling;
            }

            return result;
        }

        public bool defaultHitTestChildren(BoxHitTestResult result, Offset position = null) {
            ChildType child = lastChild;
            while (child != null) {
                ParentDataType childParentData = child.parentData as ParentDataType;
                bool isHit = result.addWithPaintOffset(
                    offset: childParentData.offset,
                    position: position,
                    hitTest: (BoxHitTestResult resultIn, Offset transformed) => {
                        D.assert(transformed == position - childParentData.offset);
                        return child.hitTest(resultIn, position: transformed);
                    }
                );
                if (isHit) {
                    return true;
                }

                child = childParentData.previousSibling;
            }

            return false;
        }

        public void defaultPaint(PaintingContext context, Offset offset) {
            var child = firstChild;
            while (child != null) {
                var childParentData = (ParentDataType) child.parentData;
                context.paintChild(child, childParentData.offset + offset);
                child = childParentData.nextSibling;
            }
        }

        public List<ChildType> getChildrenAsList() {
            var result = new List<ChildType>();
            var child = firstChild;
            while (child != null) {
                var childParentData = (ParentDataType) child.parentData;
                result.Add(child);
                child = childParentData.nextSibling;
            }

            return result;
        }
    }
}