/*
 * 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 android.support.constraint.solver.SolverVariable;
import android.support.constraint.solver.widgets.ConstraintAnchor.Type;

/**
 * Implements a mechanism to resolve nodes via a dependency graph
 */
public class ResolutionAnchor extends ResolutionNode {
    ConstraintAnchor myAnchor;
    float computedValue;
    ResolutionAnchor target;
    float offset;

    ResolutionAnchor resolvedTarget;
    float resolvedOffset;

    int type = UNCONNECTED;

    public static final int UNCONNECTED = 0;
    public static final int DIRECT_CONNECTION = 1;
    public static final int CENTER_CONNECTION = 2;
    public static final int MATCH_CONNECTION = 3;
    public static final int CHAIN_CONNECTION = 4;
    public static final int BARRIER_CONNECTION = 5;

    private ResolutionAnchor opposite;
    private float oppositeOffset;

    private ResolutionDimension dimension = null;
    private int dimensionMultiplier = 1;
    private ResolutionDimension oppositeDimension = null;
    private int oppositeDimensionMultiplier = 1;

    public ResolutionAnchor(ConstraintAnchor anchor) {
        myAnchor = anchor;
    }

    public void remove(ResolutionDimension resolutionDimension) {
        if (dimension == resolutionDimension) {
            dimension = null;
            offset = dimensionMultiplier;
        } else if (dimension == oppositeDimension) {
            oppositeDimension = null;
            oppositeOffset = oppositeDimensionMultiplier;
        }
        resolve();
    }

    @Override
    public String toString() {
        if (state == RESOLVED) {
            if (resolvedTarget == this) {
                return "[" + myAnchor + ", RESOLVED: " + resolvedOffset + "] " +  " type: " + sType(type);
            }
            return "[" + myAnchor + ", RESOLVED: " + resolvedTarget + ":" + resolvedOffset + "]"
                    + " type: " + sType(type);
        }
        return "{ " + myAnchor + " UNRESOLVED} type: " + sType(type);
    }

    public void resolve(ResolutionAnchor target, float offset) {
        if (state == UNRESOLVED || (resolvedTarget != target && resolvedOffset != offset)) {
            resolvedTarget = target;
            resolvedOffset = offset;
            if (state == RESOLVED) {
                invalidate();
            }
            didResolve();
        }
    }

    String sType(int type) {
        if (type == 1) {
            return "DIRECT";
        } else if (type == 2) {
            return "CENTER";
        } else if (type == 3) {
            return "MATCH";
        } else if (type == 4) {
            return "CHAIN";
        } else if (type == 5) {
            return "BARRIER";
        }
        return "UNCONNECTED";
    }

    @Override
    public void resolve() {
        if (ConstraintWidgetContainer.DEBUG_GRAPH) {
            System.out.println("resolve " + this + " type: " + sType(type)
                    + " current target: " + target + " with offset " + offset);
        }
        if (state == RESOLVED) {
            return;
        }
        if (type == CHAIN_CONNECTION) {
            return;
        }
        if (dimension != null) {
            if (dimension.state != RESOLVED) {
                return;
            }
            offset = dimensionMultiplier * dimension.value;
        }
        if (oppositeDimension != null) {
            if (oppositeDimension.state != RESOLVED) {
                return;
            }
            oppositeOffset = oppositeDimensionMultiplier * oppositeDimension.value;
        }
        if (type == DIRECT_CONNECTION
                && ((target == null) || (target.state == RESOLVED))) {

            // Let's solve direct connections...

            if (target == null) {
                resolvedTarget = this;
                resolvedOffset = offset;
            } else {
                resolvedTarget = target.resolvedTarget;
                resolvedOffset = target.resolvedOffset + offset;
            }
            didResolve();
        } else if (type == CENTER_CONNECTION
                && target != null
                && target.state == RESOLVED
                && opposite != null && opposite.target != null
                && opposite.target.state == RESOLVED) {

            // Let's solve center connections...

            if (LinearSystem.getMetrics() != null) {
                LinearSystem.getMetrics().centerConnectionResolved++;
            }
            resolvedTarget = target.resolvedTarget;
            opposite.resolvedTarget = opposite.target.resolvedTarget;

            float distance = 0;
            float percent = 0.5f;

            boolean isEndAnchor = myAnchor.mType == Type.RIGHT || myAnchor.mType == Type.BOTTOM;

            if (isEndAnchor) {
                // we are right or bottom
                distance = target.resolvedOffset - opposite.target.resolvedOffset;
            } else {
                distance = opposite.target.resolvedOffset - target.resolvedOffset;
            }

            if (myAnchor.mType == ConstraintAnchor.Type.LEFT
                    || myAnchor.mType == ConstraintAnchor.Type.RIGHT) {
                distance -= myAnchor.mOwner.getWidth();
                percent = myAnchor.mOwner.mHorizontalBiasPercent;
            } else {
                distance -= myAnchor.mOwner.getHeight();
                percent = myAnchor.mOwner.mVerticalBiasPercent;
            }
            int margin = myAnchor.getMargin();
            int oppositeMargin = opposite.myAnchor.getMargin();
            if (myAnchor.getTarget() == opposite.myAnchor.getTarget()) {
                percent = 0.5f;
                margin = 0;
                oppositeMargin = 0;
            }

            distance -= margin;
            distance -= oppositeMargin;

            if (isEndAnchor) {
                // we are right or bottom
                opposite.resolvedOffset = opposite.target.resolvedOffset
                        + oppositeMargin + distance * percent;
                resolvedOffset = target.resolvedOffset - margin - (distance * (1 - percent));
            } else {
                resolvedOffset = target.resolvedOffset + margin + distance * percent;
                opposite.resolvedOffset = opposite.target.resolvedOffset
                        - oppositeMargin - (distance * (1 - percent));
            }

            didResolve();
            opposite.didResolve();
        } else if (type == MATCH_CONNECTION
                && target != null
                && target.state == RESOLVED
                && opposite != null && opposite.target != null
                && opposite.target.state == RESOLVED) {

            // Let's solve match connections...

            if (LinearSystem.getMetrics() != null) {
                LinearSystem.getMetrics().matchConnectionResolved++;
            }
            resolvedTarget = target.resolvedTarget;
            opposite.resolvedTarget = opposite.target.resolvedTarget;

            resolvedOffset = target.resolvedOffset + offset;
            opposite.resolvedOffset = opposite.target.resolvedOffset + opposite.offset;

            didResolve();
            opposite.didResolve();
        } else if (type == BARRIER_CONNECTION) {
            myAnchor.mOwner.resolve();
        }
    }

    public void setType(int type) {
        this.type = type;
    }

    @Override
    public void reset() {
        super.reset();
        target = null;
        offset = 0;
        dimension = null;
        dimensionMultiplier = 1;
        oppositeDimension = null;
        oppositeDimensionMultiplier = 1;
        resolvedTarget = null;
        resolvedOffset = 0;
        computedValue = 0;
        opposite = null;
        oppositeOffset = 0;
        type = UNCONNECTED;
    }

    public void update() {
        ConstraintAnchor targetAnchor = myAnchor.getTarget();
        if (targetAnchor == null) {
            return;
        }
        if (targetAnchor.getTarget() == myAnchor) {
            type = CHAIN_CONNECTION;
            targetAnchor.getResolutionNode().type = CHAIN_CONNECTION;
        }
        int margin = myAnchor.getMargin();
        if (myAnchor.mType == ConstraintAnchor.Type.RIGHT
                || myAnchor.mType == ConstraintAnchor.Type.BOTTOM) {
            margin = -margin;
        }
        dependsOn(targetAnchor.getResolutionNode(), margin);
    }

    public void dependsOn(int type, ResolutionAnchor node, int offset) {
        this.type  = type;
        target = node;
        this.offset = offset;
        target.addDependent(this);
        if (ConstraintWidgetContainer.DEBUG_GRAPH) {
            System.out.println("a- " + this + " DEPENDS [" + sType(type) + "] ON " + node + " WITH OFFSET " + offset);
        }
    }

    public void dependsOn(ResolutionAnchor node, int offset) {
        target = node;
        this.offset = offset;
        target.addDependent(this);
        if (ConstraintWidgetContainer.DEBUG_GRAPH) {
            System.out.println("b- " + this + " DEPENDS [" + sType(type) + "] ON " + node + " WITH OFFSET " + offset);
        }
    }

    public void dependsOn(ResolutionAnchor node, int multiplier, ResolutionDimension dimension) {
        target = node;
        target.addDependent(this);
        this.dimension = dimension;
        this.dimensionMultiplier = multiplier;
        this.dimension.addDependent(this);

        if (ConstraintWidgetContainer.DEBUG_GRAPH) {
            System.out.println("c- " + this + " DEPENDS [" + sType(type) + "] ON " + node + " WITH DIMENSION " + dimension);
        }
    }

    public void setOpposite(ResolutionAnchor opposite, float oppositeOffset) {
        this.opposite = opposite;
        this.oppositeOffset = oppositeOffset;
    }

    public void setOpposite(ResolutionAnchor opposite, int multiplier, ResolutionDimension dimension) {
        this.opposite = opposite;
        this.oppositeDimension = dimension;
        this.oppositeDimensionMultiplier = multiplier;
    }

    void addResolvedValue(LinearSystem system) {
        SolverVariable sv = myAnchor.getSolverVariable();

        if (resolvedTarget == null) {
            system.addEquality(sv, (int) (resolvedOffset + 0.5f));
        } else {
            SolverVariable v = system.createObjectVariable(resolvedTarget.myAnchor);
            system.addEquality(sv, v, (int) (resolvedOffset + 0.5f), SolverVariable.STRENGTH_FIXED);
        }
    }

    public float getResolvedValue() {
        return resolvedOffset;
    }
}