/*
 * Copyright 2015 Open Networking Laboratory
 *
 * 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 org.onosproject.ui.impl.topo;

import org.onosproject.net.Link;
import org.onosproject.net.LinkKey;
import org.onosproject.net.statistic.Load;
import org.onosproject.ui.topo.LinkHighlight;

import static org.onosproject.ui.topo.LinkHighlight.Flavor.NO_HIGHLIGHT;
import static org.onosproject.ui.topo.LinkHighlight.Flavor.PRIMARY_HIGHLIGHT;
import static org.onosproject.ui.topo.LinkHighlight.Flavor.SECONDARY_HIGHLIGHT;

/**
 * Representation of a link and its inverse, and any associated traffic data.
 * This class understands how to generate {@link LinkHighlight}s for sending
 * back to the topology view.
 */
public class BiLink {

    private static final String EMPTY = "";

    private final LinkKey key;
    private final Link one;
    private Link two;

    private boolean hasTraffic = false;
    private long bytes = 0;
    private long rate = 0;
    private long flows = 0;
    private boolean isOptical = false;
    private LinkHighlight.Flavor taggedFlavor = NO_HIGHLIGHT;
    private boolean antMarch = false;

    /**
     * Constructs a bilink for the given key and initial link.
     *
     * @param key canonical key for this bilink
     * @param link first link
     */
    public BiLink(LinkKey key, Link link) {
        this.key = key;
        this.one = link;
    }

    /**
     * Sets the second link for this bilink.
     *
     * @param link second link
     */
    public void setOther(Link link) {
        this.two = link;
    }

    /**
     * Sets the optical flag to the given value.
     *
     * @param b true if an optical link
     */
    public void setOptical(boolean b) {
        isOptical = b;
    }

    /**
     * Sets the ant march flag to the given value.
     *
     * @param b true if marching ants required
     */
    public void setAntMarch(boolean b) {
        antMarch = b;
    }

    /**
     * Tags this bilink with a link flavor to be used in visual rendering.
     *
     * @param flavor the flavor to tag
     */
    public void tagFlavor(LinkHighlight.Flavor flavor) {
        this.taggedFlavor = flavor;
    }

    /**
     * Adds load statistics, marks the bilink as having traffic.
     *
     * @param load load to add
     */
    public void addLoad(Load load) {
        addLoad(load, 0);
    }

    /**
     * Adds load statistics, marks the bilink as having traffic, if the
     * load rate is greater than the given threshold.
     *
     * @param load load to add
     * @param threshold threshold to register traffic
     */
    public void addLoad(Load load, double threshold) {
        if (load != null) {
            this.hasTraffic = hasTraffic || load.rate() > threshold;
            this.bytes += load.latest();
            this.rate += load.rate();
        }
    }

    /**
     * Adds the given count of flows to this bilink.
     *
     * @param count count of flows
     */
    public void addFlows(int count) {
        this.flows += count;
    }

    /**
     * Generates a link highlight entity, based on state of this bilink.
     *
     * @param type the type of statistics to use to interpret the data
     * @return link highlight data for this bilink
     */
    public LinkHighlight generateHighlight(LinkStatsType type) {
        switch (type) {
            case FLOW_COUNT:
                return highlightForFlowCount(type);

            case FLOW_STATS:
            case PORT_STATS:
                return highlightForStats(type);

            case TAGGED:
                return highlightForTagging(type);

            default:
                throw new IllegalStateException("unexpected case: " + type);
        }
    }

    private LinkHighlight highlightForStats(LinkStatsType type) {
        return new LinkHighlight(linkId(), SECONDARY_HIGHLIGHT)
                .setLabel(generateLabel(type));
    }

    private LinkHighlight highlightForFlowCount(LinkStatsType type) {
        LinkHighlight.Flavor flavor = flows() > 0 ?
                PRIMARY_HIGHLIGHT : SECONDARY_HIGHLIGHT;
        return new LinkHighlight(linkId(), flavor)
                .setLabel(generateLabel(type));
    }

    private LinkHighlight highlightForTagging(LinkStatsType type) {
        LinkHighlight hlite = new LinkHighlight(linkId(), flavor())
                .setLabel(generateLabel(type));
        if (isOptical()) {
            hlite.addMod(LinkHighlight.MOD_OPTICAL);
        }
        if (isAntMarch()) {
            hlite.addMod(LinkHighlight.MOD_ANIMATED);
        }
        return hlite;
    }

    // Generates a link identifier in the form that the Topology View on the
    private String linkId() {
        return TopoUtils.compactLinkString(one);
    }

    // Generates a string representation of the load, to be used as a label
    private String generateLabel(LinkStatsType type) {
        switch (type) {
            case FLOW_COUNT:
                return TopoUtils.formatFlows(flows());

            case FLOW_STATS:
                return TopoUtils.formatBytes(bytes());

            case PORT_STATS:
                return TopoUtils.formatBitRate(rate());

            case TAGGED:
                return hasTraffic() ? TopoUtils.formatBytes(bytes()) : EMPTY;

            default:
                return "?";
        }
    }

    // === ----------------------------------------------------------------
    // accessors

    public LinkKey key() {
        return key;
    }

    public Link one() {
        return one;
    }

    public Link two() {
        return two;
    }

    public boolean hasTraffic() {
        return hasTraffic;
    }

    public boolean isOptical() {
        return isOptical;
    }

    public boolean isAntMarch() {
        return antMarch;
    }

    public LinkHighlight.Flavor flavor() {
        return taggedFlavor;
    }

    public long bytes() {
        return bytes;
    }

    public long rate() {
        return rate;
    }

    public long flows() {
        return flows;
    }
}