/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package android.support.constraint.solver.widgets;

import android.support.constraint.solver.LinearSystem;

import static android.support.constraint.solver.widgets.ConstraintWidget.*;
import static android.support.constraint.solver.widgets.ConstraintWidget.DimensionBehaviour.FIXED;
import static android.support.constraint.solver.widgets.ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;

/**
 * Implements direct resolution without using the solver
 */
public class Optimizer {

    // Optimization levels (mask)
    public static final int OPTIMIZATION_NONE  = 0;
    public static final int OPTIMIZATION_DIRECT = 1;
    public static final int OPTIMIZATION_BARRIER = 1 << 1;
    public static final int OPTIMIZATION_CHAIN = 1 << 2;
    public static final int OPTIMIZATION_DIMENSIONS = 1 << 3;
    public static final int OPTIMIZATION_RATIO = 1 << 4;
    public static final int OPTIMIZATION_GROUPS = 1 << 5;
    public static final int OPTIMIZATION_STANDARD = OPTIMIZATION_DIRECT
            | OPTIMIZATION_BARRIER
            | OPTIMIZATION_CHAIN
            /* | OPTIMIZATION_DIMENSIONS */
            ;

    // Internal use.
    static boolean[] flags = new boolean[3];
    static final int FLAG_USE_OPTIMIZE = 0; // simple enough to use optimizer
    static final int FLAG_CHAIN_DANGLING = 1;
    static final int FLAG_RECOMPUTE_BOUNDS = 2;

    /**
     * Looks at optimizing match_parent
     *
     * @param container
     * @param system
     * @param widget
     */
    static void checkMatchParent(ConstraintWidgetContainer container, LinearSystem system, ConstraintWidget widget) {
        if (container.mListDimensionBehaviors[DIMENSION_HORIZONTAL] != ConstraintWidget.DimensionBehaviour.WRAP_CONTENT
            && widget.mListDimensionBehaviors[DIMENSION_HORIZONTAL] == ConstraintWidget.DimensionBehaviour.MATCH_PARENT) {

            int left = widget.mLeft.mMargin;
            int right = container.getWidth() - widget.mRight.mMargin;

            if (false) {
                // TODO : activate this
                widget.mLeft.getResolutionNode().resolve(null, left);
                widget.mRight.getResolutionNode().resolve(null, right);
            } else {
                widget.mLeft.mSolverVariable = system.createObjectVariable(widget.mLeft);
                widget.mRight.mSolverVariable = system.createObjectVariable(widget.mRight);
                system.addEquality(widget.mLeft.mSolverVariable, left);
                system.addEquality(widget.mRight.mSolverVariable, right);
                widget.mHorizontalResolution = ConstraintWidget.DIRECT;
            }
            widget.setHorizontalDimension(left, right);
        }
        if (container.mListDimensionBehaviors[DIMENSION_VERTICAL] != ConstraintWidget.DimensionBehaviour.WRAP_CONTENT
            && widget.mListDimensionBehaviors[DIMENSION_VERTICAL] == ConstraintWidget.DimensionBehaviour.MATCH_PARENT) {

            int top = widget.mTop.mMargin;
            int bottom = container.getHeight() - widget.mBottom.mMargin;

            if (false) {
                // TODO : activate this
                widget.mTop.getResolutionNode().resolve(null, top);
                widget.mBottom.getResolutionNode().resolve(null, bottom);
            } else {
                widget.mTop.mSolverVariable = system.createObjectVariable(widget.mTop);
                widget.mBottom.mSolverVariable = system.createObjectVariable(widget.mBottom);
                system.addEquality(widget.mTop.mSolverVariable, top);
                system.addEquality(widget.mBottom.mSolverVariable, bottom);
                if (widget.mBaselineDistance > 0 || widget.getVisibility() == ConstraintWidget.GONE) {
                    widget.mBaseline.mSolverVariable = system.createObjectVariable(widget.mBaseline);
                    system.addEquality(widget.mBaseline.mSolverVariable, top + widget.mBaselineDistance);
                }
                widget.mVerticalResolution = ConstraintWidget.DIRECT;
            }
            widget.setVerticalDimension(top, bottom);
        }
    }

    /**
     * Returns true if the given widget is optimizable.
     *
     * This function allows us to decide which patterns are deemed directly optimizable.
     *
     * @param constraintWidget
     * @param orientation
     * @return true if optimizable
     */
    private static boolean optimizableMatchConstraint(ConstraintWidget constraintWidget, int orientation) {
        if (constraintWidget.mListDimensionBehaviors[orientation] != MATCH_CONSTRAINT) {
            return false;
        }
        if (constraintWidget.mDimensionRatio != 0) {
            if (constraintWidget.mListDimensionBehaviors[orientation == HORIZONTAL ? VERTICAL : HORIZONTAL]
                    == MATCH_CONSTRAINT) {
                return false;
            }
            // TODO -- makes this work in the optimizer -- this will be OPTIMIZATION_RATIO
            return false;
        }
        if (orientation == HORIZONTAL) {
            if (constraintWidget.mMatchConstraintDefaultWidth != MATCH_CONSTRAINT_SPREAD) {
                return false;
            }
            if (constraintWidget.mMatchConstraintMinWidth != 0 || constraintWidget.mMatchConstraintMaxWidth != 0) {
                return false;
            }
        } else {
            if (constraintWidget.mMatchConstraintDefaultHeight != MATCH_CONSTRAINT_SPREAD) {
                return false;
            }
            if (constraintWidget.mMatchConstraintMinHeight != 0 || constraintWidget.mMatchConstraintMaxHeight != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * Creates the dependency graph for the given widget
     *
     * @param widget
     */
    static void analyze(int optimisationLevel, ConstraintWidget widget) {

        // Let's update the graph from the nodes!
        // This will only apply if the nodes are not part of a chain.
        // It will set up direct connections depending on the intrinsic size (fixed or match_constraint)
        // as well as identifying centered connections and match connections.

        widget.updateResolutionNodes();

        ResolutionAnchor leftNode = widget.mLeft.getResolutionNode();
        ResolutionAnchor topNode = widget.mTop.getResolutionNode();
        ResolutionAnchor rightNode = widget.mRight.getResolutionNode();
        ResolutionAnchor bottomNode = widget.mBottom.getResolutionNode();

        boolean optimiseDimensions = (optimisationLevel & OPTIMIZATION_DIMENSIONS) == OPTIMIZATION_DIMENSIONS;

        // First the horizontal nodes...

        boolean isOptimizableHorizontalMatch = widget.mListDimensionBehaviors[HORIZONTAL] == MATCH_CONSTRAINT
            && optimizableMatchConstraint(widget, HORIZONTAL);

        if (leftNode.type != ResolutionAnchor.CHAIN_CONNECTION
                && rightNode.type != ResolutionAnchor.CHAIN_CONNECTION) {
            if (widget.mListDimensionBehaviors[HORIZONTAL] == FIXED
                || (isOptimizableHorizontalMatch && widget.getVisibility() == ConstraintWidget.GONE)) {
                if (widget.mLeft.mTarget == null && widget.mRight.mTarget == null) {
                    leftNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    rightNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    if (optimiseDimensions) {
                        rightNode.dependsOn(leftNode, 1, widget.getResolutionWidth());
                    } else {
                        rightNode.dependsOn(leftNode, widget.getWidth());
                    }
                } else if (widget.mLeft.mTarget != null && widget.mRight.mTarget == null) {
                    leftNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    rightNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    if (optimiseDimensions) {
                        rightNode.dependsOn(leftNode, 1, widget.getResolutionWidth());
                    } else {
                        rightNode.dependsOn(leftNode, widget.getWidth());
                    }
                } else if (widget.mLeft.mTarget == null && widget.mRight.mTarget != null) {
                    leftNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    rightNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    leftNode.dependsOn(rightNode, -widget.getWidth());
                    if (optimiseDimensions) {
                        leftNode.dependsOn(rightNode, -1, widget.getResolutionWidth());
                    } else {
                        leftNode.dependsOn(rightNode, -widget.getWidth());
                    }
                } else if (widget.mLeft.mTarget != null && widget.mRight.mTarget != null) {
                    leftNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                    rightNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                    if (optimiseDimensions) {
                        widget.getResolutionWidth().addDependent(leftNode);
                        widget.getResolutionWidth().addDependent(rightNode);
                        leftNode.setOpposite(rightNode, -1, widget.getResolutionWidth());
                        rightNode.setOpposite(leftNode, 1, widget.getResolutionWidth());
                    } else {
                        leftNode.setOpposite(rightNode, -widget.getWidth());
                        rightNode.setOpposite(leftNode, widget.getWidth());
                    }
                }
            } else if (isOptimizableHorizontalMatch) {
                int width = widget.getWidth();
                // TODO: ratio won't work with optimiseDimensions as it is
                // ...but ratio won't work period for now as optimizableMatchConstraint will return false
                // if (widget.mDimensionRatio != 0) {
                //     width = (int) (widget.getHeight() * widget.mDimensionRatio);
                // }
                leftNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                rightNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                if (widget.mLeft.mTarget == null && widget.mRight.mTarget == null) {
                    if (optimiseDimensions) {
                        rightNode.dependsOn(leftNode, 1, widget.getResolutionWidth());
                    } else {
                        rightNode.dependsOn(leftNode, width);
                    }
                } else if (widget.mLeft.mTarget != null && widget.mRight.mTarget == null) {
                    if (optimiseDimensions) {
                        rightNode.dependsOn(leftNode, 1, widget.getResolutionWidth());
                    } else {
                        rightNode.dependsOn(leftNode, width);
                    }
                } else if (widget.mLeft.mTarget == null && widget.mRight.mTarget != null) {
                    if (optimiseDimensions) {
                        leftNode.dependsOn(rightNode, -1, widget.getResolutionWidth());
                    } else {
                        leftNode.dependsOn(rightNode, -width);
                    }
                } else if (widget.mLeft.mTarget != null && widget.mRight.mTarget != null) {
                    if (optimiseDimensions) {
                        widget.getResolutionWidth().addDependent(leftNode);
                        widget.getResolutionWidth().addDependent(rightNode);
                    }
                    if (widget.mDimensionRatio == 0) {
                        leftNode.setType(ResolutionAnchor.MATCH_CONNECTION);
                        rightNode.setType(ResolutionAnchor.MATCH_CONNECTION);
                        leftNode.setOpposite(rightNode, 0);
                        rightNode.setOpposite(leftNode, 0);
                    } else {
                        // TODO -- fix ratio. For now this won't work.
                        leftNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                        rightNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                        leftNode.setOpposite(rightNode, -width);
                        rightNode.setOpposite(leftNode, width);
                        widget.setWidth(width);
                    }
                }
            }
        }

        // ...then the vertical ones

      boolean isOptimizableVerticalMatch = widget.mListDimensionBehaviors[VERTICAL] == MATCH_CONSTRAINT
          && optimizableMatchConstraint(widget, VERTICAL);

      if (topNode.type != ResolutionAnchor.CHAIN_CONNECTION
                && bottomNode.type != ResolutionAnchor.CHAIN_CONNECTION
                /* && mBaseline.getResolutionNode().type == ResolutionAnchor.UNCONNECTED */) {
            if (widget.mListDimensionBehaviors[VERTICAL] == FIXED
                || (isOptimizableVerticalMatch && widget.getVisibility() == ConstraintWidget.GONE)) {
                if (widget.mTop.mTarget == null && widget.mBottom.mTarget == null) {
                    topNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    bottomNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    if (optimiseDimensions) {
                        bottomNode.dependsOn(topNode, 1, widget.getResolutionHeight());
                    } else {
                        bottomNode.dependsOn(topNode, widget.getHeight());
                    }
                    if (widget.mBaseline.mTarget != null) {
                        widget.mBaseline.getResolutionNode().setType(ResolutionAnchor.DIRECT_CONNECTION);
                        topNode.dependsOn(ResolutionAnchor.DIRECT_CONNECTION,
                                widget.mBaseline.getResolutionNode(), -widget.mBaselineDistance);
                    }
                } else if (widget.mTop.mTarget != null && widget.mBottom.mTarget == null) {
                    topNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    bottomNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    if (optimiseDimensions) {
                        bottomNode.dependsOn(topNode, 1, widget.getResolutionHeight());
                    } else {
                        bottomNode.dependsOn(topNode, widget.getHeight());
                    }
                    if (widget.mBaselineDistance > 0) {
                        widget.mBaseline.getResolutionNode().dependsOn(ResolutionAnchor.DIRECT_CONNECTION, topNode, widget.mBaselineDistance);
                    }
                } else if (widget.mTop.mTarget == null && widget.mBottom.mTarget != null) {
                    topNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    bottomNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                    if (optimiseDimensions) {
                        topNode.dependsOn(bottomNode, -1, widget.getResolutionHeight());
                    } else {
                        topNode.dependsOn(bottomNode, -widget.getHeight());
                    }
                    if (widget.mBaselineDistance > 0) {
                        widget.mBaseline.getResolutionNode().dependsOn(ResolutionAnchor.DIRECT_CONNECTION, topNode, widget.mBaselineDistance);
                    }
                } else if (widget.mTop.mTarget != null && widget.mBottom.mTarget != null) {
                    topNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                    bottomNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                    if (optimiseDimensions) {
                        topNode.setOpposite(bottomNode, -1, widget.getResolutionHeight());
                        bottomNode.setOpposite(topNode, 1, widget.getResolutionHeight());
                        widget.getResolutionHeight().addDependent(topNode);
                        widget.getResolutionWidth().addDependent(bottomNode);
                    } else {
                        topNode.setOpposite(bottomNode, -widget.getHeight());
                        bottomNode.setOpposite(topNode, widget.getHeight());
                    }
                    if (widget.mBaselineDistance > 0) {
                        widget.mBaseline.getResolutionNode().dependsOn(ResolutionAnchor.DIRECT_CONNECTION, topNode, widget.mBaselineDistance);
                    }
                }
            } else if (isOptimizableVerticalMatch) {
                int height = widget.getHeight();
                // TODO: fix ratio (right it won't work, optimizableMatchConstraint will return false
                // if (widget.mDimensionRatio != 0) {
                //     height = (int) (widget.getWidth() * widget.mDimensionRatio);
                // }
                topNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                bottomNode.setType(ResolutionAnchor.DIRECT_CONNECTION);
                if (widget.mTop.mTarget == null && widget.mBottom.mTarget == null) {
                    if (optimiseDimensions) {
                        bottomNode.dependsOn(topNode, 1, widget.getResolutionHeight());
                    } else {
                        bottomNode.dependsOn(topNode, height);
                    }
                } else if (widget.mTop.mTarget != null && widget.mBottom.mTarget == null) {
                    if (optimiseDimensions) {
                        bottomNode.dependsOn(topNode, 1, widget.getResolutionHeight());
                    } else {
                        bottomNode.dependsOn(topNode, height);
                    }
                } else if (widget.mTop.mTarget == null && widget.mBottom.mTarget != null) {
                    if (optimiseDimensions) {
                        topNode.dependsOn(bottomNode, -1, widget.getResolutionHeight());
                    } else {
                        topNode.dependsOn(bottomNode, -height);
                    }
                } else if (widget.mTop.mTarget != null && widget.mBottom.mTarget != null) {
                    if (optimiseDimensions) {
                        widget.getResolutionHeight().addDependent(topNode);
                        widget.getResolutionWidth().addDependent(bottomNode);
                    }
                    if (widget.mDimensionRatio == 0) {
                        topNode.setType(ResolutionAnchor.MATCH_CONNECTION);
                        bottomNode.setType(ResolutionAnchor.MATCH_CONNECTION);
                        topNode.setOpposite(bottomNode, 0);
                        bottomNode.setOpposite(topNode, 0);
                    } else {
                        topNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                        bottomNode.setType(ResolutionAnchor.CENTER_CONNECTION);
                        topNode.setOpposite(bottomNode, -height);
                        bottomNode.setOpposite(topNode, height);
                        widget.setHeight(height);
                        if (widget.mBaselineDistance > 0) {
                            widget.mBaseline.getResolutionNode().dependsOn(ResolutionAnchor.DIRECT_CONNECTION, topNode, widget.mBaselineDistance);
                        }
                    }
                }
            }
        }
    }

    /**
     * Try to apply the chain using the resolution nodes
     *
     * @param container
     * @param system
     * @param orientation
     * @param offset
     * @param chainHead
     *
     * @return true if the chain has been optimized, false otherwise
     */
    static boolean applyChainOptimized(ConstraintWidgetContainer container, LinearSystem system,
                                      int orientation, int offset, ChainHead chainHead) {

        ConstraintWidget first = chainHead.mFirst;
        ConstraintWidget last = chainHead.mLast;
        ConstraintWidget firstVisibleWidget = chainHead.mFirstVisibleWidget;
        ConstraintWidget lastVisibleWidget = chainHead.mLastVisibleWidget;
        ConstraintWidget head = chainHead.mHead;

        ConstraintWidget widget = first;
        ConstraintWidget next = null;
        boolean done = false;

        int numMatchConstraints = 0;
        float totalWeights = chainHead.mTotalWeight;
        ConstraintWidget firstMatchConstraintsWidget = chainHead.mFirstMatchConstraintWidget;
        ConstraintWidget previousMatchConstraintsWidget = chainHead.mLastMatchConstraintWidget;

        boolean isWrapContent = container.mListDimensionBehaviors[orientation] == DimensionBehaviour.WRAP_CONTENT;
        boolean isChainSpread = false;
        boolean isChainSpreadInside = false;
        boolean isChainPacked = false;

        if (orientation == ConstraintWidget.HORIZONTAL) {
            isChainSpread = head.mHorizontalChainStyle == ConstraintWidget.CHAIN_SPREAD;
            isChainSpreadInside = head.mHorizontalChainStyle == ConstraintWidget.CHAIN_SPREAD_INSIDE;
            isChainPacked = head.mHorizontalChainStyle == ConstraintWidget.CHAIN_PACKED;
        } else {
            isChainSpread = head.mVerticalChainStyle == ConstraintWidget.CHAIN_SPREAD;
            isChainSpreadInside = head.mVerticalChainStyle == ConstraintWidget.CHAIN_SPREAD_INSIDE;
            isChainPacked = head.mVerticalChainStyle == ConstraintWidget.CHAIN_PACKED;
        }

        // The first traversal will:
        // - set up some basic ordering constraints
        // - build a linked list of matched constraints widgets

        float totalSize = 0;
        float totalMargins = 0;
        int numVisibleWidgets = 0;

        while (!done) {
            // Measure visible widgets and add margins.
            if (widget.getVisibility() != ConstraintWidget.GONE) {
                numVisibleWidgets ++;
                if (orientation == HORIZONTAL) {
                    totalSize += widget.getWidth();
                } else {
                    totalSize += widget.getHeight();
                }
                if (widget != firstVisibleWidget) {
                    totalSize += widget.mListAnchors[offset].getMargin();
                }
                if (widget != lastVisibleWidget) {
                    totalSize += widget.mListAnchors[offset + 1].getMargin();
                }
                totalMargins += widget.mListAnchors[offset].getMargin();
                totalMargins += widget.mListAnchors[offset + 1].getMargin();
            }

            ConstraintAnchor begin = widget.mListAnchors[offset];

            if (widget.getVisibility() != ConstraintWidget.GONE
                    && widget.mListDimensionBehaviors[orientation] == MATCH_CONSTRAINT) {
                numMatchConstraints++;
                // only supports basic match_constraints
                if (orientation == HORIZONTAL) {
                    if (widget.mMatchConstraintDefaultWidth != ConstraintWidget.MATCH_CONSTRAINT_SPREAD) {
                        return false;
                    } else if (widget.mMatchConstraintMinWidth != 0 || widget.mMatchConstraintMaxWidth != 0) {
                        return false;
                    }
                } else {
                    if (widget.mMatchConstraintDefaultHeight != ConstraintWidget.MATCH_CONSTRAINT_SPREAD) {
                        return false;
                    } else if (widget.mMatchConstraintMinHeight != 0 || widget.mMatchConstraintMaxHeight != 0) {
                        return false;
                    }
                }
                if (widget.mDimensionRatio != 0.0f) {
                    return false;
                }
            }

            // go to the next widget
            ConstraintAnchor nextAnchor = widget.mListAnchors[offset + 1].mTarget;
            if (nextAnchor != null) {
                next = nextAnchor.mOwner;
                if (next.mListAnchors[offset].mTarget == null || next.mListAnchors[offset].mTarget.mOwner != widget) {
                    next = null;
                }
            } else {
                next = null;
            }
            if (next != null) {
                widget = next;
            } else {
                done = true;
            }
        }

        ResolutionAnchor firstNode = first.mListAnchors[offset].getResolutionNode();
        ResolutionAnchor lastNode = last.mListAnchors[offset + 1].getResolutionNode();

        if (firstNode.target == null || lastNode.target == null) {
            // dangling chain, let's bail for now
            return false;
        }

        // let's look at the endpoints
        if (firstNode.target.state != ResolutionAnchor.RESOLVED
                || lastNode.target.state != ResolutionAnchor.RESOLVED) {
            // No resolved endpoints, let's exit
            return false;
        }

        if (numMatchConstraints > 0 && numMatchConstraints != numVisibleWidgets) {
            // for now, only supports basic case
            return false;
        }

        float extraMargin = 0;
        if (isChainPacked || isChainSpread || isChainSpreadInside) {
            if (firstVisibleWidget != null) {
                extraMargin = firstVisibleWidget.mListAnchors[offset].getMargin();
            }
            if (lastVisibleWidget != null) {
                extraMargin += lastVisibleWidget.mListAnchors[offset + 1].getMargin();
            }
        }

        float firstOffset = firstNode.target.resolvedOffset;
        float lastOffset = lastNode.target.resolvedOffset;
        float distance = 0;
        if (firstOffset < lastOffset) {
            distance = lastOffset - firstOffset - totalSize;
        } else {
            distance = firstOffset - lastOffset - totalSize;
        }

        if (numMatchConstraints > 0 && numMatchConstraints == numVisibleWidgets) {
            if (widget.getParent() != null && widget.getParent().mListDimensionBehaviors[orientation] == DimensionBehaviour.WRAP_CONTENT) {
                return false;
            }
            distance += totalSize;
            distance -= totalMargins;
            widget = first;
            float position = firstOffset;
            while (widget != null) {
                if (system.sMetrics != null) {
                    system.sMetrics.nonresolvedWidgets--;
                    system.sMetrics.resolvedWidgets++;
                    system.sMetrics.chainConnectionResolved++;
                }
                next = widget.mNextChainWidget[orientation];
                if (next != null || widget == last) {
                    float dimension = distance / numMatchConstraints;
                    if (totalWeights > 0) {
                        if (widget.mWeight[orientation] == UNKNOWN) {
                            dimension = 0;
                        } else {
                            dimension = widget.mWeight[orientation] * distance / totalWeights;
                        }
                    }
                    if (widget.getVisibility() == GONE) {
                        dimension = 0;
                    }
                    position += widget.mListAnchors[offset].getMargin();
                    widget.mListAnchors[offset].getResolutionNode().resolve(firstNode.resolvedTarget,
                            position);
                    widget.mListAnchors[offset + 1].getResolutionNode().resolve(firstNode.resolvedTarget,
                            position + dimension);
                    widget.mListAnchors[offset].getResolutionNode().addResolvedValue(system);
                    widget.mListAnchors[offset + 1].getResolutionNode().addResolvedValue(system);
                    position += dimension;
                    position += widget.mListAnchors[offset + 1].getMargin();
                }
                widget = next;
            }
            return true;
        }

        // If there is not enough space, the chain has to behave as a packed chain.
        if (distance < 0) {
            isChainSpread = false;
            isChainSpreadInside = false;
            isChainPacked = true;
        }

        if (isChainPacked) {
            distance -= extraMargin;
            // Now let's iterate on those widgets
            widget = first;
            distance = firstOffset + (distance * first.getBiasPercent(orientation)); // start after the gap
            while (widget != null) {
                if (system.sMetrics != null) {
                    system.sMetrics.nonresolvedWidgets--;
                    system.sMetrics.resolvedWidgets++;
                    system.sMetrics.chainConnectionResolved++;
                }
                next = widget.mNextChainWidget[orientation];
                if (next != null || widget == last) {
                    float dimension = 0;
                    if (orientation == HORIZONTAL) {
                        dimension = widget.getWidth();
                    } else {
                        dimension = widget.getHeight();
                    }
                    distance += widget.mListAnchors[offset].getMargin();
                    widget.mListAnchors[offset].getResolutionNode().resolve(firstNode.resolvedTarget,
                            distance);
                    widget.mListAnchors[offset + 1].getResolutionNode().resolve(firstNode.resolvedTarget,
                            distance + dimension);
                    widget.mListAnchors[offset].getResolutionNode().addResolvedValue(system);
                    widget.mListAnchors[offset + 1].getResolutionNode().addResolvedValue(system);
                    distance += dimension;
                    distance += widget.mListAnchors[offset + 1].getMargin();
                }
                widget = next;
            }
        } else if (isChainSpread || isChainSpreadInside) {
            if (isChainSpread) {
                distance -= extraMargin;
            } else if (isChainSpreadInside) {
                distance -= extraMargin;
            }
            widget = first;
            float gap = distance / (float) (numVisibleWidgets + 1);
            if (isChainSpreadInside) {
                if (numVisibleWidgets > 1) {
                    gap = distance / (float) (numVisibleWidgets - 1);
                } else {
                    gap = distance / 2f; // center
                }
            }
            distance = firstOffset;
            if (first.getVisibility() != GONE) {
                distance += gap; // start after the gap
            }
            if (isChainSpreadInside && numVisibleWidgets > 1) {
                distance = firstOffset + firstVisibleWidget.mListAnchors[offset].getMargin();
            }
            if (isChainSpread) {
                if (firstVisibleWidget != null) {
                    distance += firstVisibleWidget.mListAnchors[offset].getMargin();
                }
            }
            while (widget != null) {
                if (system.sMetrics != null) {
                    system.sMetrics.nonresolvedWidgets--;
                    system.sMetrics.resolvedWidgets++;
                    system.sMetrics.chainConnectionResolved++;
                }
                next = widget.mNextChainWidget[orientation];
                if (next != null || widget == last) {
                    float dimension = 0;
                    if (orientation == HORIZONTAL) {
                        dimension = widget.getWidth();
                    } else {
                        dimension = widget.getHeight();
                    }
                    if (widget != firstVisibleWidget) {
                        distance += widget.mListAnchors[offset].getMargin();
                    }
                    widget.mListAnchors[offset].getResolutionNode().resolve(firstNode.resolvedTarget,
                            distance);
                    widget.mListAnchors[offset + 1].getResolutionNode().resolve(firstNode.resolvedTarget,
                            distance + dimension);
                    widget.mListAnchors[offset].getResolutionNode().addResolvedValue(system);
                    widget.mListAnchors[offset + 1].getResolutionNode().addResolvedValue(system);
                    distance += dimension + widget.mListAnchors[offset + 1].getMargin();
                    if (next != null && next.getVisibility() != GONE) {
                        distance += gap;
                    }
                }
                widget = next;
            }
        }

        return true; // optimized!
    }

    //TODO: Might want to use ResolutionAnchor::resolve(target, offset).
    /**
     * Set a {@link ConstraintWidget} optimized position and dimension in an specific orientation.
     *
     * @param widget         Widget to be optimized.
     * @param orientation    Orientation to set optimization (HORIZONTAL{0}/VERTICAL{1}).
     * @param resolvedOffset The resolved offset of the widget with respect to the root.
     */
    static void setOptimizedWidget(ConstraintWidget widget, int orientation, int resolvedOffset) {
        final int startOffset = orientation * 2;
        final int endOffset = startOffset + 1;
        // Left/top of widget.
        widget.mListAnchors[startOffset].getResolutionNode().resolvedTarget =
                widget.getParent().mLeft.getResolutionNode();
        widget.mListAnchors[startOffset].getResolutionNode().resolvedOffset =
                resolvedOffset;
        widget.mListAnchors[startOffset].getResolutionNode().state = ResolutionNode.RESOLVED;
        // Right/bottom of widget.
        widget.mListAnchors[endOffset].getResolutionNode().resolvedTarget =
                widget.mListAnchors[startOffset].getResolutionNode();
        widget.mListAnchors[endOffset].getResolutionNode().resolvedOffset =
                widget.getLength(orientation);
        widget.mListAnchors[endOffset].getResolutionNode().state = ResolutionNode.RESOLVED;
    }
}