/*
 *  Copyright 2016-present 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.util;

import org.onosproject.net.Link;
import org.onosproject.net.LinkKey;
import org.onosproject.net.statistic.Load;
import org.onosproject.ui.model.topo.UiLinkId;
import org.onosproject.ui.topo.BiLink;
import org.onosproject.ui.topo.LinkHighlight;
import org.onosproject.ui.topo.LinkHighlight.Flavor;
import org.onosproject.ui.topo.Mod;
import org.onosproject.ui.topo.TopoUtils.Magnitude;
import org.onosproject.ui.topo.TopoUtils.ValueLabel;

import java.util.HashSet;
import java.util.Set;

import static com.google.common.base.MoreObjects.toStringHelper;
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;
import static org.onosproject.ui.topo.TopoUtils.formatBytes;
import static org.onosproject.ui.topo.TopoUtils.formatClippedBitRate;
import static org.onosproject.ui.topo.TopoUtils.formatFlows;
import static org.onosproject.ui.topo.TopoUtils.formatPacketRate;

/**
 * Representation of a link and its inverse, and associated traffic data.
 * This class understands how to generate the appropriate
 * {@link LinkHighlight}s for showing traffic data on the topology view.
 */
public class TrafficLink extends BiLink {
    private static final Mod PORT_TRAFFIC_GREEN = new Mod("port-traffic-green");
    private static final Mod PORT_TRAFFIC_YELLOW = new Mod("port-traffic-yellow");
    private static final Mod PORT_TRAFFIC_ORANGE = new Mod("port-traffic-orange");
    private static final Mod PORT_TRAFFIC_RED = new Mod("port-traffic-red");

    private static final String EMPTY = "";

    private long bytes = 0;
    private long rate = 0;
    private long flows = 0;
    private Flavor taggedFlavor = NO_HIGHLIGHT;
    private boolean hasTraffic = false;
    private boolean isOptical = false;
    private boolean antMarch = false;
    private Set<Mod> mods = new HashSet<>();

    /**
     * Constructs a traffic link for the given key and initial link.
     *
     * @param key  canonical key for this traffic link
     * @param link first link
     */
    public TrafficLink(LinkKey key, Link link) {
        super(key, link);
    }


    /**
     * Returns an "empty" traffic link (one with no underlying links or stats)
     * with the given identifier. This is useful when we want to aggregate
     * stats from other links into a single entity (such as a region-region
     * link reporting the stats for the links that compose it).
     *
     * @param id the link identifier
     */
    public TrafficLink(UiLinkId id) {
        super(id);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        TrafficLink that = (TrafficLink) o;

        return bytes == that.bytes && rate == that.rate &&
                flows == that.flows && hasTraffic == that.hasTraffic &&
                isOptical == that.isOptical && antMarch == that.antMarch &&
                taggedFlavor == that.taggedFlavor && mods.equals(that.mods);
    }

    @Override
    public int hashCode() {
        int result = (int) (bytes ^ (bytes >>> 32));
        result = 31 * result + (int) (rate ^ (rate >>> 32));
        result = 31 * result + (int) (flows ^ (flows >>> 32));
        result = 31 * result + taggedFlavor.hashCode();
        result = 31 * result + (hasTraffic ? 1 : 0);
        result = 31 * result + (isOptical ? 1 : 0);
        result = 31 * result + (antMarch ? 1 : 0);
        result = 31 * result + mods.hashCode();
        return result;
    }

    @Override
    public String toString() {
        return toStringHelper(this)
                .add("linkId", linkId())
                .add("bytes", bytes)
                .add("rate", rate)
                .add("flows", flows)
                .toString();
    }

    /**
     * Returns the count of bytes.
     *
     * @return the byte count
     */
    public long bytes() {
        return bytes;
    }

    /**
     * Returns the rate.
     *
     * @return the rate
     */
    public long rate() {
        return rate;
    }

    /**
     * Returns the flows.
     *
     * @return flow count
     */
    public long flows() {
        return flows;
    }

    /**
     * Sets the optical flag to the given value.
     *
     * @param b true if an optical link
     * @return self, for chaining
     */
    public TrafficLink optical(boolean b) {
        isOptical = b;
        return this;
    }

    /**
     * Sets the ant march flag to the given value.
     *
     * @param b true if marching ants required
     * @return self, for chaining
     */
    public TrafficLink antMarch(boolean b) {
        antMarch = b;
        return this;
    }

    /**
     * Tags this traffic link with the flavor to be used in visual rendering.
     *
     * @param flavor the flavor to tag
     * @return self, for chaining
     */
    public TrafficLink tagFlavor(Flavor flavor) {
        taggedFlavor = flavor;
        return this;
    }

    /**
     * Tags this traffic link with the mods to be used in visual rendering.
     *
     * @param mods the mods to tag on this link
     * @return self, for chaining
     */
    public TrafficLink tagMods(Set<Mod> mods) {
        if (mods != null) {
            this.mods.addAll(mods);
        }
        return this;
    }

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

    /**
     * Adds load statistics, marks the traffic link as having traffic, if the
     * load {@link Load#rate rate} is greater than the given threshold
     * (expressed in bytes per second).
     *
     * @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 traffic link.
     *
     * @param count count of flows
     */
    public void addFlows(int count) {
        this.flows += count;
    }

    /**
     * Merges the load recorded on the given traffic link into this one.
     *
     * @param other the other traffic link
     */
    public void mergeStats(TrafficLink other) {
        this.bytes += other.bytes;
        this.rate += other.rate;
        this.flows += other.flows;
    }


    @Override
    public LinkHighlight highlight(Enum<?> type) {
        StatsType statsType = (StatsType) type;
        switch (statsType) {
            case FLOW_COUNT:
                return highlightForFlowCount();

            case FLOW_STATS:
            case PORT_STATS:
            case PORT_PACKET_STATS:
                return highlightForStats(statsType);

            case TAGGED:
                return highlightForTagging();

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

    private LinkHighlight highlightForStats(StatsType type) {
        ValueLabel vl = null;
        Mod m = null;

        // based on the type of stats, need to determine the label and "color"...
        switch (type) {
            case FLOW_STATS:
                vl = formatBytes(bytes);
                // default to "secondary highlighting" of link
                break;

            case PORT_STATS:
                vl = formatClippedBitRate(rate);

                // set color based on bits per second...
                if (vl.magnitude() == Magnitude.ONE ||
                        vl.magnitude() == Magnitude.KILO) {
                    m = PORT_TRAFFIC_GREEN;

                } else if (vl.magnitude() == Magnitude.MEGA) {
                    m = PORT_TRAFFIC_YELLOW;

                } else if (vl.magnitude() == Magnitude.GIGA) {
                    m = vl.clipped() ? PORT_TRAFFIC_RED : PORT_TRAFFIC_ORANGE;
                }
                break;

            case PORT_PACKET_STATS:
                vl = formatPacketRate(rate);

                // FIXME: Provisional color threshold parameters for packets
                // set color based on bits per second...
                if (rate < 10) {
                    m = PORT_TRAFFIC_GREEN;

                } else if (rate < 1000) {
                    m = PORT_TRAFFIC_YELLOW;

                } else if (rate < 100000) {
                    m = PORT_TRAFFIC_ORANGE;
                } else {
                    m = PORT_TRAFFIC_RED;
                }
                break;

            default:
                break;
        }

        LinkHighlight hlite = new LinkHighlight(linkId(), SECONDARY_HIGHLIGHT);
        if (vl != null) {
            hlite.setLabel(vl.toString());
        }
        if (m != null) {
            hlite.addMod(m);
        }

        return addCustomMods(hlite);
    }

    private LinkHighlight highlightForFlowCount() {
        Flavor flavor = flows > 0 ? PRIMARY_HIGHLIGHT : SECONDARY_HIGHLIGHT;
        LinkHighlight hlite = new LinkHighlight(linkId(), flavor)
                .setLabel(formatFlows(flows));

        return addCustomMods(hlite);
    }

    private LinkHighlight highlightForTagging() {
        LinkHighlight hlite = new LinkHighlight(linkId(), taggedFlavor)
                .setLabel(hasTraffic ? formatBytes(bytes).toString() : EMPTY);

        if (isOptical) {
            hlite.addMod(LinkHighlight.MOD_OPTICAL);
        }
        if (antMarch) {
            hlite.addMod(LinkHighlight.MOD_ANIMATED);
        }
        return addCustomMods(hlite);
    }

    private LinkHighlight addCustomMods(LinkHighlight hlite) {
        if (!mods.isEmpty()) {
            mods.forEach(hlite::addMod);
        }
        return hlite;
    }

    /**
     * Returns true if this link has been deemed to have enough traffic
     * to register on the topology view in the web UI.
     *
     * @return true if this link has displayable traffic
     */
    public boolean hasTraffic() {
        return hasTraffic;
    }

    /**
     * Designates type of traffic statistics to report on a highlighted link.
     */
    public enum StatsType {
        /**
         * Number of flows.
         */
        FLOW_COUNT,

        /**
         * Number of bytes.
         */
        FLOW_STATS,

        /**
         * Number of bits per second.
         */
        PORT_STATS,

        /**
         * Number of packets per second.
         */
        PORT_PACKET_STATS,

        /**
         * Custom tagged information.
         */
        TAGGED
    }
}