/*
 * Copyright 2017-present Open Networking Foundation
 *
 * 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.drivers.server;

import org.onosproject.drivers.server.behavior.CpuStatisticsDiscovery;
import org.onosproject.drivers.server.behavior.MonitoringStatisticsDiscovery;
import org.onosproject.drivers.server.devices.cpu.CpuCacheHierarchyDevice;
import org.onosproject.drivers.server.devices.cpu.CpuDevice;
import org.onosproject.drivers.server.devices.memory.MemoryHierarchyDevice;
import org.onosproject.drivers.server.devices.nic.NicDevice;
import org.onosproject.drivers.server.devices.ServerDeviceDescription;
import org.onosproject.drivers.server.devices.RestServerSBDevice;
import org.onosproject.drivers.server.stats.CpuStatistics;
import org.onosproject.drivers.server.stats.MemoryStatistics;
import org.onosproject.drivers.server.stats.MonitoringStatistics;
import org.onosproject.drivers.server.stats.TimingStatistics;

import org.onosproject.drivers.server.impl.devices.DefaultBasicCpuCacheDevice;
import org.onosproject.drivers.server.impl.devices.DefaultCpuCacheHierarchyDevice;
import org.onosproject.drivers.server.impl.devices.DefaultCpuDevice;
import org.onosproject.drivers.server.impl.devices.DefaultMemoryHierarchyDevice;
import org.onosproject.drivers.server.impl.devices.DefaultMemoryModuleDevice;
import org.onosproject.drivers.server.impl.devices.DefaultNicDevice;
import org.onosproject.drivers.server.impl.devices.DefaultRestServerSBDevice;
import org.onosproject.drivers.server.impl.devices.DefaultServerDeviceDescription;
import org.onosproject.drivers.server.impl.stats.DefaultCpuStatistics;
import org.onosproject.drivers.server.impl.stats.DefaultMemoryStatistics;
import org.onosproject.drivers.server.impl.stats.DefaultMonitoringStatistics;
import org.onosproject.drivers.server.impl.stats.DefaultTimingStatistics;

import org.onlab.packet.ChassisId;
import org.onosproject.net.AnnotationKeys;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.DefaultAnnotations;
import org.onosproject.net.behaviour.DevicesDiscovery;
import org.onosproject.net.behaviour.DeviceCpuStats;
import org.onosproject.net.behaviour.DeviceMemoryStats;
import org.onosproject.net.behaviour.DeviceSystemStatisticsQuery;
import org.onosproject.net.behaviour.DeviceSystemStats;
import org.onosproject.net.device.DeviceDescription;
import org.onosproject.net.device.DeviceDescriptionDiscovery;
import org.onosproject.net.device.DefaultPortStatistics;
import org.onosproject.net.device.DefaultPortDescription;
import org.onosproject.net.device.PortDescription;
import org.onosproject.net.device.PortStatistics;
import org.onosproject.net.device.PortStatisticsDiscovery;
import org.onosproject.net.PortNumber;
import org.onosproject.protocol.rest.RestSBDevice;

import org.slf4j.Logger;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.collect.ImmutableList;

import java.io.InputStream;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import javax.ws.rs.ProcessingException;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.onosproject.drivers.server.Constants.JSON;
import static org.onosproject.drivers.server.Constants.MSG_DEVICE_NULL;
import static org.onosproject.drivers.server.Constants.MSG_DEVICE_ID_NULL;
import static org.onosproject.drivers.server.Constants.MSG_NIC_NAME_NULL;
import static org.onosproject.drivers.server.Constants.MSG_NIC_PORT_NUMBER_NEGATIVE;
import static org.onosproject.drivers.server.Constants.MSG_STATS_TIMING_DEPLOY_INCONSISTENT;
import static org.onosproject.drivers.server.Constants.PARAM_ID;
import static org.onosproject.drivers.server.Constants.PARAM_CAPACITY;
import static org.onosproject.drivers.server.Constants.PARAM_CHASSIS_ID;
import static org.onosproject.drivers.server.Constants.PARAM_CPUS;
import static org.onosproject.drivers.server.Constants.PARAM_NICS;
import static org.onosproject.drivers.server.Constants.PARAM_NAME;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_HIERARCHY;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_MODULES;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_STATS_FREE;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_STATS_TOTAL;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_STATS_USED;
import static org.onosproject.drivers.server.Constants.PARAM_MANUFACTURER;
import static org.onosproject.drivers.server.Constants.PARAM_HW_VENDOR;
import static org.onosproject.drivers.server.Constants.PARAM_SW_VENDOR;
import static org.onosproject.drivers.server.Constants.PARAM_SERIAL;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_STATS;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_STATS_AUTOSCALE;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_LEVEL;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_LEVELS;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_LINE_LEN;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_POLICY;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_SETS;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_SHARED;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_TYPE;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_WAYS;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHES;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CACHE_HIERARCHY;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_CORES;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_FREQUENCY;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_ID_LOG;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_ID_PHY;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_LOAD;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_LATENCY;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_QUEUE;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_SOCKET;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_SOCKETS;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_STATUS;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_THROUGHPUT;
import static org.onosproject.drivers.server.Constants.PARAM_CPU_VENDOR;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_WIDTH_DATA;
import static org.onosproject.drivers.server.Constants.PARAM_MEMORY_WIDTH_TOTAL;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_HW_ADDR;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_PORT_TYPE;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_RX_FILTER;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_RX_COUNT;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_RX_BYTES;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_RX_DROPS;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_RX_ERRORS;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_TX_COUNT;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_TX_BYTES;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_TX_DROPS;
import static org.onosproject.drivers.server.Constants.PARAM_NIC_STATS_TX_ERRORS;
import static org.onosproject.drivers.server.Constants.PARAM_MON_AVERAGE;
import static org.onosproject.drivers.server.Constants.PARAM_MON_BUSY_CPUS;
import static org.onosproject.drivers.server.Constants.PARAM_MON_FREE_CPUS;
import static org.onosproject.drivers.server.Constants.PARAM_MON_MAX;
import static org.onosproject.drivers.server.Constants.PARAM_MON_MIN;
import static org.onosproject.drivers.server.Constants.PARAM_MON_UNIT;
import static org.onosproject.drivers.server.Constants.PARAM_SPEED;
import static org.onosproject.drivers.server.Constants.PARAM_SPEED_CONF;
import static org.onosproject.drivers.server.Constants.PARAM_STATUS;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_PARSE;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_LAUNCH;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_DEPLOY;
import static org.onosproject.drivers.server.Constants.PARAM_TIMING_AUTOSCALE;
import static org.onosproject.drivers.server.Constants.PARAM_TYPE;
import static org.onosproject.drivers.server.Constants.SLASH;
import static org.onosproject.drivers.server.Constants.URL_SRV_GLOBAL_STATS;
import static org.onosproject.drivers.server.Constants.URL_SRV_RESOURCE_DISCOVERY;
import static org.onosproject.drivers.server.Constants.URL_SERVICE_CHAINS_STATS;
import static org.slf4j.LoggerFactory.getLogger;

/**
 * Discovers the device details of server devices.
 */
public class ServerDevicesDiscovery
        extends BasicServerDriver
        implements  DevicesDiscovery, DeviceDescriptionDiscovery,
                    PortStatisticsDiscovery, CpuStatisticsDiscovery,
                    MonitoringStatisticsDiscovery, DeviceSystemStatisticsQuery {

    private final Logger log = getLogger(getClass());

    /**
     * Auxiliary constants.
     */
    private static final short DISCOVERY_RETRIES = 3;

    /**
     * Constructs server device discovery.
     */
    public ServerDevicesDiscovery() {
        super();
        log.debug("Started");
    }

    /**
     * Implements DevicesDiscovery behaviour.
     */
    @Override
    public Set<DeviceId> deviceIds() {
        // Set of devices to return
        Set<DeviceId> devices = new HashSet<DeviceId>();

        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);
        devices.add(deviceId);

        return devices;
    }

    @Override
    public DeviceDescription deviceDetails(DeviceId deviceId) {
        return getDeviceDetails(deviceId);
    }

    /**
     * Implements DeviceDescriptionDiscovery behaviour.
     */
    @Override
    public DeviceDescription discoverDeviceDetails() {
        return getDeviceDetails(null);
    }

    /**
     * Query a server to retrieve its features.
     *
     * @param deviceId the device ID to be queried
     * @return a DeviceDescription with the device's features
     */
    private DeviceDescription getDeviceDetails(DeviceId deviceId) {
        // Retrieve the device ID, if null given
        if (deviceId == null) {
            deviceId = getDeviceId();
            checkNotNull(deviceId, MSG_DEVICE_ID_NULL);
        }

        // Get the device
        RestSBDevice device = getDevice(deviceId);
        checkNotNull(device, MSG_DEVICE_NULL);

        // Hit the path that provides the server's resources
        InputStream response = null;
        try {
            response = getController().get(deviceId, URL_SRV_RESOURCE_DISCOVERY, JSON);
        } catch (ProcessingException pEx) {
            log.error("Failed to discover the device details of: {}", deviceId);
            return null;
        }

        // Load the JSON into objects
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> jsonMap = null;
        JsonNode jsonNode = null;
        ObjectNode objNode = null;
        try {
            jsonMap  = mapper.readValue(response, Map.class);
            jsonNode = mapper.convertValue(jsonMap, JsonNode.class);
            objNode = (ObjectNode) jsonNode;
        } catch (IOException ioEx) {
            log.error("Failed to discover the device details of: {}", deviceId);
            return null;
        }

        if (jsonMap == null) {
            log.error("Failed to discover the device details of: {}", deviceId);
            return null;
        }

        // Get all the attributes
        String id      = get(jsonNode, PARAM_ID);
        String vendor  = get(jsonNode, PARAM_MANUFACTURER);
        String hw      = get(jsonNode, PARAM_HW_VENDOR);
        String sw      = get(jsonNode, PARAM_SW_VENDOR);
        String serial  = get(jsonNode, PARAM_SERIAL);
        long chassisId = objNode.path(PARAM_CHASSIS_ID).asLong();

        // Pass the southbound protocol as an annotation
        DefaultAnnotations.Builder annotations = DefaultAnnotations.builder();
        annotations.set(AnnotationKeys.PROTOCOL, "REST");

        // Parse CPU devices
        Collection<CpuDevice> cpuSet = parseCpuDevices(objNode);

        // Parse memory hierarchy device
        MemoryHierarchyDevice memHierarchyDev = parseMemoryHierarchyDevice(objNode);

        // Parse CPU cache hierachy device
        CpuCacheHierarchyDevice cacheHierarchyDev = parseCpuCacheHierarchyDevice(objNode);

        // NICs are composite attributes too
        Collection<NicDevice> nicSet = parseNicDevices(mapper, objNode, annotations);

        // Construct a server device,
        // i.e., a RestSBDevice extended with CPU, cache, memory, and NIC information
        RestServerSBDevice dev = new DefaultRestServerSBDevice(
            device.ip(), device.port(), device.username(),
            device.password(), device.protocol(), device.url(),
            device.isActive(), device.testUrl().orElse(""),
            vendor, hw, sw, cpuSet, cacheHierarchyDev,
            memHierarchyDev, nicSet);
        checkNotNull(dev, MSG_DEVICE_NULL);

        // Set alive
        raiseDeviceReconnect(dev);

        // Updates the controller with the complete device information
        getController().removeDevice(deviceId);
        getController().addDevice((RestSBDevice) dev);

        // Create a description for this server device
        ServerDeviceDescription desc = null;
        try {
            desc = new DefaultServerDeviceDescription(
                new URI(id), Device.Type.SERVER, vendor,
                hw, sw, serial, new ChassisId(chassisId),
                cpuSet, cacheHierarchyDev, memHierarchyDev,
                nicSet, annotations.build());
        } catch (URISyntaxException uEx) {
            log.error("Failed to create a server device description for: {}",
                deviceId);
            return null;
        }

        log.info("Device's {} details sent to the controller", deviceId);

        return desc;
    }

    /**
     * Parse the input JSON object, looking for CPU-related
     * information. Upon success, construct and return a list
     * of CPU devices.
     *
     * @param objNode input JSON node with CPU device information
     * @return list of CPU devices
     */
    private Collection<CpuDevice> parseCpuDevices(ObjectNode objNode) {
        Collection<CpuDevice> cpuSet = Sets.newHashSet();
        JsonNode cpuNode = objNode.path(PARAM_CPUS);

        // Construct CPU objects
        for (JsonNode cn : cpuNode) {
            ObjectNode cpuObjNode = (ObjectNode) cn;

            // All the CPU attributes
            int   physicalCpuId = cpuObjNode.path(PARAM_CPU_ID_PHY).asInt();
            int    logicalCpuId = cpuObjNode.path(PARAM_CPU_ID_LOG).asInt();
            int       cpuSocket = cpuObjNode.path(PARAM_CPU_SOCKET).asInt();
            String cpuVendorStr = get(cn, PARAM_CPU_VENDOR);
            long   cpuFrequency = cpuObjNode.path(PARAM_CPU_FREQUENCY).asLong();

            // Construct a CPU device and add it to the set
            cpuSet.add(
                DefaultCpuDevice.builder()
                    .setCoreId(logicalCpuId, physicalCpuId)
                    .setVendor(cpuVendorStr)
                    .setSocket(cpuSocket)
                    .setFrequency(cpuFrequency)
                    .build());
        }

        return cpuSet;
    }

    /**
     * Parse the input JSON object, looking for CPU cache-related
     * information. Upon success, construct and return a CPU cache
     * hierarchy device.
     *
     * @param objNode input JSON node with CPU cache device information
     * @return a CPU cache hierarchy devices
     */
    private CpuCacheHierarchyDevice parseCpuCacheHierarchyDevice(ObjectNode objNode) {
        JsonNode cacheHierarchyNode = objNode.path(PARAM_CPU_CACHE_HIERARCHY);
        ObjectNode cacheHierarchyObjNode = (ObjectNode) cacheHierarchyNode;
        if (cacheHierarchyObjNode == null) {
            return null;
        }

        int socketsNb = cacheHierarchyObjNode.path(PARAM_CPU_SOCKETS).asInt();
        int coresNb = cacheHierarchyObjNode.path(PARAM_CPU_CORES).asInt();
        int levels = cacheHierarchyObjNode.path(PARAM_CPU_CACHE_LEVELS).asInt();

        JsonNode cacheNode = cacheHierarchyObjNode.path(PARAM_CPU_CACHES);

        DefaultCpuCacheHierarchyDevice.Builder cacheBuilder =
            DefaultCpuCacheHierarchyDevice.builder()
                .setSocketsNumber(socketsNb)
                .setCoresNumber(coresNb)
                .setLevels(levels);

        // Construct CPU cache objects
        for (JsonNode cn : cacheNode) {
            ObjectNode cacheObjNode = (ObjectNode) cn;

            // CPU cache attributes
            String cpuVendorStr = get(cn, PARAM_CPU_VENDOR);
            String     levelStr = get(cn, PARAM_CPU_CACHE_LEVEL);
            String      typeStr = get(cn, PARAM_CPU_CACHE_TYPE);
            String    policyStr = get(cn, PARAM_CPU_CACHE_POLICY);
            long       capacity = cacheObjNode.path(PARAM_CAPACITY).asLong();
            int            sets = cacheObjNode.path(PARAM_CPU_CACHE_SETS).asInt();
            int            ways = cacheObjNode.path(PARAM_CPU_CACHE_WAYS).asInt();
            int         lineLen = cacheObjNode.path(PARAM_CPU_CACHE_LINE_LEN).asInt();
            boolean      shared = cacheObjNode.path(PARAM_CPU_CACHE_SHARED).asInt() > 0;

            // Construct a basic CPU cache device and add it to the hierarchy
            cacheBuilder.addBasicCpuCacheDevice(
                DefaultBasicCpuCacheDevice.builder()
                    .setVendor(cpuVendorStr)
                    .setCacheId(levelStr, typeStr)
                    .setPolicy(policyStr)
                    .setCapacity(capacity)
                    .setNumberOfSets(sets)
                    .setNumberOfWays(ways)
                    .setLineLength(lineLen)
                    .isShared(shared)
                    .build());
        }

        return cacheBuilder.build();
    }

    /**
     * Parse the input JSON object, looking for memory-related
     * information. Upon success, construct and return a memory
     * hierarchy device.
     *
     * @param objNode input JSON node with memory device information
     * @return a memory hierarchy device
     */
    private MemoryHierarchyDevice parseMemoryHierarchyDevice(ObjectNode objNode) {
        JsonNode memHierarchyNode = objNode.path(PARAM_MEMORY_HIERARCHY);
        ObjectNode memoryHierarchyObjNode = (ObjectNode) memHierarchyNode;
        if (memoryHierarchyObjNode == null) {
            return null;
        }

        JsonNode memoryNode = memoryHierarchyObjNode.path(PARAM_MEMORY_MODULES);

        DefaultMemoryHierarchyDevice.Builder memoryBuilder =
            DefaultMemoryHierarchyDevice.builder();

        // Construct memory modules
        for (JsonNode mn : memoryNode) {
            ObjectNode memoryObjNode = (ObjectNode) mn;

            String typeStr = get(mn, PARAM_TYPE);
            String manufacturerStr = get(mn, PARAM_MANUFACTURER);
            String serialStr = get(mn, PARAM_SERIAL);
            int dataWidth = memoryObjNode.path(PARAM_MEMORY_WIDTH_DATA).asInt();
            int totalWidth = memoryObjNode.path(PARAM_MEMORY_WIDTH_TOTAL).asInt();
            long capacity = memoryObjNode.path(PARAM_CAPACITY).asLong();
            long speed = memoryObjNode.path(PARAM_SPEED).asLong();
            long configuredSpeed = memoryObjNode.path(PARAM_SPEED_CONF).asLong();

            // Construct a memory module and add it to the hierarchy
            memoryBuilder.addMemoryModule(
                DefaultMemoryModuleDevice.builder()
                    .setType(typeStr)
                    .setManufacturer(manufacturerStr)
                    .setSerialNumber(serialStr)
                    .setDataWidth(dataWidth)
                    .setTotalWidth(totalWidth)
                    .setCapacity(capacity)
                    .setSpeed(speed)
                    .setConfiguredSpeed(configuredSpeed)
                    .build());
        }

        return memoryBuilder.build();
    }

    /**
     * Parse the input JSON object, looking for NIC-related
     * information. Upon success, construct and return a list
     * of NIC devices.
     *
     * @param mapper input JSON object mapper
     * @param objNode input JSON node with NIC device information
     * @param annotations device annotations
     * @return list of CPU devices
     */
    private Collection<NicDevice> parseNicDevices(
            ObjectMapper mapper, ObjectNode objNode, DefaultAnnotations.Builder annotations) {
        Collection<NicDevice> nicSet = Sets.newHashSet();
        JsonNode nicNode = objNode.path(PARAM_NICS);

        // Construct NIC objects
        for (JsonNode nn : nicNode) {
            ObjectNode nicObjNode = (ObjectNode) nn;

            // All the NIC attributes
            String nicName     = get(nn, PARAM_NAME);
            long nicIndex      = nicObjNode.path(PARAM_ID).asLong();
            long speed         = nicObjNode.path(PARAM_SPEED).asLong();
            String portTypeStr = get(nn, PARAM_NIC_PORT_TYPE);
            boolean status     = nicObjNode.path(PARAM_STATUS).asInt() > 0;
            String hwAddr      = get(nn, PARAM_NIC_HW_ADDR);
            JsonNode tagNode   = nicObjNode.path(PARAM_NIC_RX_FILTER);
            if (tagNode == null) {
                throw new IllegalArgumentException(
                    "The Rx filters of NIC " + nicName + " are not reported");
            }

            // Convert the JSON list into an array of strings
            List<String> rxFilters = null;
            try {
                rxFilters = mapper.readValue(tagNode.traverse(),
                    new TypeReference<ArrayList<String>>() { });
            } catch (IOException ioEx) {
                continue;
            }

            // Store NIC name to number mapping as an annotation
            annotations.set(nicName, Long.toString(nicIndex));

            // Construct a NIC device and add it to the set
            nicSet.add(
                DefaultNicDevice.builder()
                    .setName(nicName)
                    .setPortNumber(nicIndex)
                    .setPortNumber(nicIndex)
                    .setPortType(portTypeStr)
                    .setSpeed(speed)
                    .setStatus(status)
                    .setMacAddress(hwAddr)
                    .setRxFilters(rxFilters)
                    .build());
        }

        return nicSet;
    }

    @Override
    public List<PortDescription> discoverPortDetails() {
        // Retrieve the device ID
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // .. and object
        RestServerSBDevice device = null;
        try {
            device = (RestServerSBDevice) getDevice(deviceId);
        } catch (ClassCastException ccEx) {
            log.error("Failed to discover ports for device {}", deviceId);
            return Collections.EMPTY_LIST;
        }

        if (device == null) {
            log.error("No device with ID {} is available for port discovery", deviceId);
            return Collections.EMPTY_LIST;
        }
        if ((device.nics() == null) || (device.nics().size() == 0)) {
            log.error("No ports available on {}", deviceId);
            return Collections.EMPTY_LIST;
        }

        // List of port descriptions to return
        List<PortDescription> portDescriptions = Lists.newArrayList();

        // Sorted list of NIC ports
        Set<NicDevice> nics = new TreeSet(device.nics());

        // Iterate through the NICs of this device to populate the list
        for (NicDevice nic : nics) {
            // Include the name of this device as an annotation
            DefaultAnnotations.Builder annotations = DefaultAnnotations.builder()
                                .set(AnnotationKeys.PORT_NAME, nic.name());

            // Create a port description and add it to the list
            portDescriptions.add(
                    DefaultPortDescription.builder()
                            // CHECK: .withPortNumber(PortNumber.portNumber(nic.portNumber(), nic.name()))
                            .withPortNumber(PortNumber.portNumber(nic.portNumber()))
                            .isEnabled(nic.status())
                            .type(nic.portType())
                            .portSpeed(nic.speed())
                            .annotations(annotations.build())
                            .build());

            log.info("Port discovery on device {}: NIC {} is {} at {} Mbps",
                deviceId, nic.portNumber(), nic.status() ? "up" : "down",
                nic.speed());
        }

        return ImmutableList.copyOf(portDescriptions);
    }

    /**
     * Implements PortStatisticsDiscovery behaviour.
     */
    @Override
    public Collection<PortStatistics> discoverPortStatistics() {
        // Retrieve the device ID
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // Get port statistics for this device
        return getPortStatistics(deviceId);
    }

    /**
     * Query a server to retrieve its port statistics.
     *
     * @param deviceId the device ID to be queried
     * @return list of (per port) PortStatistics
     */
    private Collection<PortStatistics> getPortStatistics(DeviceId deviceId) {
        // Get global monitoring statistics
        MonitoringStatistics monStats = getGlobalMonitoringStatistics(deviceId);
        if (monStats == null) {
            return Collections.EMPTY_LIST;
        }

        // Filter out the NIC statistics
        Collection<PortStatistics> portStats = monStats.nicStatisticsAll();
        if (portStats == null) {
            return Collections.EMPTY_LIST;
        }

        log.debug("Port statistics: {}", portStats.toString());

        return portStats;
    }

    /**
     * Implements CpuStatisticsDiscovery behaviour.
     */
    @Override
    public Collection<CpuStatistics> discoverCpuStatistics() {
        // Retrieve the device ID
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // Get CPU statistics for this device
        return getCpuStatistics(deviceId);
    }

    /**
     * Query a server to retrieve its CPU statistics.
     *
     * @param deviceId the device ID to be queried
     * @return list of (per core) CpuStatistics
     */
     public Collection<CpuStatistics> getCpuStatistics(DeviceId deviceId) {
        // Get global monitoring statistics
        MonitoringStatistics monStats = getGlobalMonitoringStatistics(deviceId);
        if (monStats == null) {
            return Collections.EMPTY_LIST;
        }

        // Filter out the CPU statistics
        Collection<CpuStatistics> cpuStats = monStats.cpuStatisticsAll();
        if (cpuStats == null) {
            return Collections.EMPTY_LIST;
        }

        log.debug("CPU statistics: {}", cpuStats.toString());

        return cpuStats;
    }

    /**
     * Implements MonitoringStatisticsDiscovery behaviour.
     */
    @Override
    public MonitoringStatistics discoverGlobalMonitoringStatistics() {
        // Retrieve the device ID
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // Get global monitoring statistics for this device
        return getGlobalMonitoringStatistics(deviceId);
    }

    /**
     * Query a server to retrieve its global monitoring statistics.
     *
     * @param deviceId the device ID to be queried
     * @return global monitoring statistics
     */
     public MonitoringStatistics getGlobalMonitoringStatistics(DeviceId deviceId) {
        // Monitoring statistics to return
        MonitoringStatistics monStats = null;

        RestServerSBDevice device = null;
        try {
            device = (RestServerSBDevice) getDevice(deviceId);
        } catch (ClassCastException ccEx) {
            log.error("Failed to retrieve global monitoring statistics from device {}",
                deviceId);
            return monStats;
        }
        if ((device == null) || (!device.isActive())) {
            return monStats;
        }

        // Hit the path that provides the server's global resources
        InputStream response = null;
        try {
            response = getController().get(deviceId, URL_SRV_GLOBAL_STATS, JSON);
        } catch (ProcessingException pEx) {
            log.error("Failed to retrieve global monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        // Load the JSON into objects
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> jsonMap = null;
        ObjectNode objNode = null;
        try {
            jsonMap  = mapper.readValue(response, Map.class);
            JsonNode jsonNode = mapper.convertValue(jsonMap, JsonNode.class);
            objNode = (ObjectNode) jsonNode;
        } catch (IOException ioEx) {
            log.error("Failed to retrieve global monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        if (jsonMap == null) {
            log.error("Failed to retrieve global monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        // Get high-level CPU statistics
        int busyCpus = objNode.path(PARAM_MON_BUSY_CPUS).asInt();
        int freeCpus = objNode.path(PARAM_MON_FREE_CPUS).asInt();

        // Get a list of CPU statistics per core
        Collection<CpuStatistics> cpuStats = parseCpuStatistics(deviceId, objNode);

        // Get main memory statistics
        MemoryStatistics memStats = parseMemoryStatistics(deviceId, objNode);

        // Get a list of port statistics
        Collection<PortStatistics> nicStats = parseNicStatistics(deviceId, objNode);

        // Get zero timing statistics
        TimingStatistics timinsgStats = getZeroTimingStatistics();

        // Construct a global monitoring statistics object out of smaller ones
        monStats = DefaultMonitoringStatistics.builder()
                    .setDeviceId(deviceId)
                    .setTimingStatistics(timinsgStats)
                    .setCpuStatistics(cpuStats)
                    .setMemoryStatistics(memStats)
                    .setNicStatistics(nicStats)
                    .build();

        // When a device reports monitoring data, it means it is alive
        raiseDeviceReconnect(device);

        log.debug("Global monitoring statistics: {}", monStats.toString());

        return monStats;
    }

    @Override
    public MonitoringStatistics discoverMonitoringStatistics(URI tcId) {
        // Retrieve the device ID
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // Get resource-specific monitoring statistics for this device
        return getMonitoringStatistics(deviceId, tcId);
    }

    /**
     * Query a server to retrieve monitoring statistics for a
     * specific resource (i.e., traffic class).
     *
     * @param deviceId the device ID to be queried
     * @param tcId the ID of the traffic class to be monitored
     * @return resource-specific monitoring statistics
     */
     private MonitoringStatistics getMonitoringStatistics(DeviceId deviceId, URI tcId) {
        // Monitoring statistics to return
        MonitoringStatistics monStats = null;

        RestServerSBDevice device = null;
        try {
            device = (RestServerSBDevice) getDevice(deviceId);
        } catch (ClassCastException ccEx) {
            log.error("Failed to retrieve monitoring statistics from device {}",
                deviceId);
            return monStats;
        }
        if (device == null) {
            return monStats;
        }

        // Create a resource-specific URL
        String scUrl = URL_SERVICE_CHAINS_STATS + SLASH + tcId.toString();

        // Hit the path that provides the server's specific resources
        InputStream response = null;
        try {
            response = getController().get(deviceId, scUrl, JSON);
        } catch (ProcessingException pEx) {
            log.error("Failed to retrieve monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        // Load the JSON into objects
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> jsonMap = null;
        JsonNode jsonNode  = null;
        ObjectNode objNode = null;
        try {
            jsonMap  = mapper.readValue(response, Map.class);
            jsonNode = mapper.convertValue(jsonMap, JsonNode.class);
            objNode = (ObjectNode) jsonNode;
        } catch (IOException ioEx) {
            log.error("Failed to retrieve monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        if (jsonMap == null) {
            log.error("Failed to retrieve monitoring statistics from device {}",
                deviceId);
            raiseDeviceDisconnect(device);
            return monStats;
        }

        // Get the ID of the traffic class
        String id = get(jsonNode, PARAM_ID);

        // And verify that this is the traffic class we want to monitor
        if (!id.equals(tcId.toString())) {
            throw new IllegalStateException(
                "Failed to retrieve monitoring data for traffic class " + tcId +
                ". Traffic class ID does not agree."
            );
        }

        // Get a list of CPU statistics per core
        Collection<CpuStatistics> cpuStats = parseCpuStatistics(deviceId, objNode);

        // Get main memory statistics
        MemoryStatistics memStats = parseMemoryStatistics(deviceId, objNode);

        // Get a list of port statistics
        Collection<PortStatistics> nicStats = parseNicStatistics(deviceId, objNode);

        // Get timing statistics
        TimingStatistics timinsgStats = parseTimingStatistics(objNode);

        // Construct a global monitoring statistics object out of smaller ones
        monStats = DefaultMonitoringStatistics.builder()
                    .setDeviceId(deviceId)
                    .setTimingStatistics(timinsgStats)
                    .setCpuStatistics(cpuStats)
                    .setMemoryStatistics(memStats)
                    .setNicStatistics(nicStats)
                    .build();

        // When a device reports monitoring data, it means it is alive
        raiseDeviceReconnect(device);

        log.debug("Monitoring statistics: {}", monStats.toString());

        return monStats;
    }

    /**
     * Parse the input JSON object, looking for CPU-related
     * statistics. Upon success, construct and return a list
     * of CPU statistics objects.
     *
     * @param deviceId the device ID that sent the JSON object
     * @param objNode input JSON node with CPU statistics information
     * @return list of (per core) CpuStatistics
     */
    private Collection<CpuStatistics> parseCpuStatistics(DeviceId deviceId, JsonNode objNode) {
        if ((deviceId == null) || (objNode == null)) {
            return Collections.EMPTY_LIST;
        }

        Collection<CpuStatistics> cpuStats = Lists.newArrayList();

        JsonNode cpuNode = objNode.path(PARAM_CPUS);

        for (JsonNode cn : cpuNode) {
            ObjectNode cpuObjNode = (ObjectNode) cn;

            // CPU statistics builder
            DefaultCpuStatistics.Builder cpuStatsBuilder = DefaultCpuStatistics.builder();

            // Throughput statistics are optional
            JsonNode throughputNode = cpuObjNode.get(PARAM_CPU_THROUGHPUT);
            if (throughputNode != null) {
                String throughputUnit = get(throughputNode, PARAM_MON_UNIT);
                if (!Strings.isNullOrEmpty(throughputUnit)) {
                    cpuStatsBuilder.setThroughputUnit(throughputUnit);
                }
                float averageThroughput = (float) 0;
                if (throughputNode.get(PARAM_MON_AVERAGE) != null) {
                    averageThroughput = throughputNode.path(PARAM_MON_AVERAGE).floatValue();
                }
                cpuStatsBuilder.setAverageThroughput(averageThroughput);
            }

            // Latency statistics are optional
            JsonNode latencyNode = cpuObjNode.get(PARAM_CPU_LATENCY);
            if (latencyNode != null) {
                String latencyUnit = get(latencyNode, PARAM_MON_UNIT);
                if (!Strings.isNullOrEmpty(latencyUnit)) {
                    cpuStatsBuilder.setLatencyUnit(latencyUnit);
                }
                float minLatency = (float) 0;
                if (latencyNode.get(PARAM_MON_MIN) != null) {
                    minLatency = latencyNode.path(PARAM_MON_MIN).floatValue();
                }
                float averageLatency = (float) 0;
                if (latencyNode.get(PARAM_MON_AVERAGE) != null) {
                    averageLatency = latencyNode.path(PARAM_MON_AVERAGE).floatValue();
                }
                float maxLatency = (float) 0;
                if (latencyNode.get(PARAM_MON_MAX) != null) {
                    maxLatency = latencyNode.path(PARAM_MON_MAX).floatValue();
                }

                cpuStatsBuilder.setMinLatency(minLatency)
                    .setAverageLatency(averageLatency)
                    .setMaxLatency(maxLatency);
            }

            // CPU ID with its load and status
            int cpuId = cpuObjNode.path(PARAM_ID).asInt();
            float cpuLoad = cpuObjNode.path(PARAM_CPU_LOAD).floatValue();
            int queueId = cpuObjNode.path(PARAM_CPU_QUEUE).asInt();
            int busySince = cpuObjNode.path(PARAM_CPU_STATUS).asInt();

            // We have all the statistics for this CPU core
            cpuStats.add(
                cpuStatsBuilder
                    .setDeviceId(deviceId)
                    .setId(cpuId)
                    .setLoad(cpuLoad)
                    .setQueue(queueId)
                    .setBusySince(busySince)
                    .build());
        }

        return cpuStats;
    }

    /**
     * Parse the input JSON object, looking for memory-related
     * statistics. Upon success, construct and return a memory
     * statistics objects.
     *
     * @param deviceId the device ID that sent the JSON object
     * @param objNode input JSON node with memory statistics information
     * @return memory statistics object
     */
    private MemoryStatistics parseMemoryStatistics(DeviceId deviceId, JsonNode objNode) {
        if ((deviceId == null) || (objNode == null)) {
            return null;
        }

        JsonNode memoryNode = objNode.path(PARAM_MEMORY);
        ObjectNode memoryObjNode = (ObjectNode) memoryNode;

        // Fetch memory statistics
        String unit = get(memoryNode, PARAM_MON_UNIT);
        long used = memoryObjNode.path(PARAM_MEMORY_STATS_USED).asLong();
        long free = memoryObjNode.path(PARAM_MEMORY_STATS_FREE).asLong();
        long total = memoryObjNode.path(PARAM_MEMORY_STATS_TOTAL).asLong();

        // Memory statistics builder
        return DefaultMemoryStatistics.builder()
                .setDeviceId(deviceId)
                .setMemoryUsed(used)
                .setMemoryFree(free)
                .setMemoryTotal(total)
                .build();
    }

    /**
     * Parse the input JSON object, looking for NIC-related
     * statistics. Upon success, construct and return a list
     * of NIC statistics objects.
     *
     * @param deviceId the device ID that sent the JSON object
     * @param objNode input JSON node with NIC statistics information
     * @return list of (per port) PortStatistics
     */
    private Collection<PortStatistics> parseNicStatistics(DeviceId deviceId, JsonNode objNode) {
        if ((deviceId == null) || (objNode == null)) {
            return Collections.EMPTY_LIST;
        }

        RestServerSBDevice device = null;
        try {
            device = (RestServerSBDevice) getDevice(deviceId);
        } catch (ClassCastException ccEx) {
            return Collections.EMPTY_LIST;
        }
        if (device == null) {
            return Collections.EMPTY_LIST;
        }

        Collection<PortStatistics> nicStats = Lists.newArrayList();

        JsonNode nicNode = objNode.path(PARAM_NICS);

        for (JsonNode nn : nicNode) {
            ObjectNode nicObjNode = (ObjectNode) nn;

            // All the NIC attributes
            String nicName  = get(nn, PARAM_NAME);
            checkArgument(!Strings.isNullOrEmpty(nicName), MSG_NIC_NAME_NULL);

            long portNumber = device.portNumberFromName(nicName);
            checkArgument(portNumber >= 0, MSG_NIC_PORT_NUMBER_NEGATIVE);

            long rxCount   = nicObjNode.path(PARAM_NIC_STATS_RX_COUNT).asLong();
            long rxBytes   = nicObjNode.path(PARAM_NIC_STATS_RX_BYTES).asLong();
            long rxDropped = nicObjNode.path(PARAM_NIC_STATS_RX_DROPS).asLong();
            long rxErrors  = nicObjNode.path(PARAM_NIC_STATS_RX_ERRORS).asLong();
            long txCount   = nicObjNode.path(PARAM_NIC_STATS_TX_COUNT).asLong();
            long txBytes   = nicObjNode.path(PARAM_NIC_STATS_TX_BYTES).asLong();
            long txDropped = nicObjNode.path(PARAM_NIC_STATS_TX_DROPS).asLong();
            long txErrors  = nicObjNode.path(PARAM_NIC_STATS_TX_ERRORS).asLong();

            // Construct a NIC statistics object and add it to the set
            nicStats.add(
                DefaultPortStatistics.builder()
                    .setDeviceId(deviceId)
                    .setPort(PortNumber.portNumber(portNumber))
                    .setPacketsReceived(rxCount)
                    .setPacketsSent(txCount)
                    .setBytesReceived(rxBytes)
                    .setBytesSent(txBytes)
                    .setPacketsRxDropped(rxDropped)
                    .setPacketsRxErrors(rxErrors)
                    .setPacketsTxDropped(txDropped)
                    .setPacketsTxErrors(txErrors)
                    .build());
        }

        return nicStats;
    }

    /**
     * Parse the input JSON object, looking for timing-related statistics.
     * Upon success, return a timing statistics object with the advertized values.
     * Upon failure, return a timing statistics object with zero-initialized values.
     *
     * @param objNode input JSON node with timing statistics information
     * @return TimingStatistics object or null
     */
    private TimingStatistics parseTimingStatistics(JsonNode objNode) {
        TimingStatistics timinsgStats = null;

        if (objNode == null) {
            return timinsgStats;
        }

        // If no timing statistics are present, then send zeros
        if (objNode.get(PARAM_TIMING_STATS) == null) {
            return getZeroTimingStatistics();
        }

        DefaultTimingStatistics.Builder timingBuilder =
            DefaultTimingStatistics.builder();

        // Get timing statistics
        JsonNode timingNode = objNode.path(PARAM_TIMING_STATS);
        ObjectNode timingObjNode = (ObjectNode) timingNode;

        // The unit of timing statistics
        String timingStatsUnit = get(timingNode, PARAM_MON_UNIT);
        if (!Strings.isNullOrEmpty(timingStatsUnit)) {
            timingBuilder.setUnit(timingStatsUnit);
        }

        // Time (ns) to parse the controller's deployment instruction
        long parsingTime = 0;
        if (timingObjNode.get(PARAM_TIMING_PARSE) != null) {
            parsingTime = timingObjNode.path(PARAM_TIMING_PARSE).asLong();
        }
        // Time (ns) to do the deployment
        long launchingTime = 0;
        if (timingObjNode.get(PARAM_TIMING_LAUNCH) != null) {
            launchingTime = timingObjNode.path(PARAM_TIMING_LAUNCH).asLong();
        }
        // Deployment time (ns) equals to time to parse + time to launch
        long deployTime = 0;
        if (timingObjNode.get(PARAM_TIMING_DEPLOY) != null) {
            deployTime = timingObjNode.path(PARAM_TIMING_DEPLOY).asLong();
        }
        checkArgument(deployTime == parsingTime + launchingTime,
            MSG_STATS_TIMING_DEPLOY_INCONSISTENT);

        timingBuilder.setParsingTime(parsingTime)
                    .setLaunchingTime(launchingTime);

        // Get autoscale timing statistics
        JsonNode autoscaleTimingNode = objNode.path(PARAM_TIMING_STATS_AUTOSCALE);
        if (autoscaleTimingNode == null) {
            return timingBuilder.build();
        }

        ObjectNode autoScaleTimingObjNode = (ObjectNode) autoscaleTimingNode;
        // Time (ns) to autoscale a server's load
        long autoScaleTime = 0;
        if (autoScaleTimingObjNode.get(PARAM_TIMING_AUTOSCALE) != null) {
            autoScaleTime = autoScaleTimingObjNode.path(PARAM_TIMING_AUTOSCALE).asLong();
        }
        timingBuilder.setAutoScaleTime(autoScaleTime);

        return timingBuilder.build();
    }

    /**
     * Return a timing statistics object with zero counters.
     * This is useful when constructing MonitoringStatistics
     * objects that do not require timers.
     *
     * @return TimingStatistics object
     */
    private TimingStatistics getZeroTimingStatistics() {
        return DefaultTimingStatistics.builder()
                    .setParsingTime(0)
                    .setLaunchingTime(0)
                    .setAutoScaleTime(0)
                    .build();
    }

    /**
     * Implements DeviceSystemStatisticsQuery behaviour.
     */
    @Override
    public Optional<DeviceSystemStats> getDeviceSystemStats() {
        // Retrieve the device ID from the handler
        DeviceId deviceId = getDeviceId();
        checkNotNull(deviceId, MSG_DEVICE_ID_NULL);

        // ....to retrieve monitoring statistics
        MonitoringStatistics monStats = getGlobalMonitoringStatistics(deviceId);

        Optional<DeviceCpuStats> cpuStats = getOverallCpuUsage(monStats);
        Optional<DeviceMemoryStats> memoryStats = getOverallMemoryUsage(monStats);

        if (cpuStats.isPresent() && memoryStats.isPresent()) {
            return Optional.of(new DeviceSystemStats(memoryStats.get(), cpuStats.get()));
        } else {
            return Optional.empty();
        }
    }

    /**
     * Get CPU usage of server device.
     *
     * @param monStats global monitoring statistics which contain CPU statistics
     * @return cpuStats, device CPU usage stats if available
     */
    private Optional<DeviceCpuStats> getOverallCpuUsage(MonitoringStatistics monStats) {
        if (monStats == null) {
            return Optional.empty();
        }

        if (monStats.numberOfCpus() == 0) {
            return Optional.of(new DeviceCpuStats());
        }

        float usedCpu = 0.0f;
        for (CpuStatistics cpuCoreStats : monStats.cpuStatisticsAll()) {
            if (cpuCoreStats.busy()) {
                usedCpu += cpuCoreStats.load();
            }
        }

        return Optional.of(new DeviceCpuStats(usedCpu / (float) monStats.numberOfCpus()));
    }

    /**
     * Get memory usage of server device in KB.
     *
     * @param monStats global monitoring statistics which contain memory statistics
     * @return memoryStats, device memory usage stats if available
     */
    private Optional<DeviceMemoryStats> getOverallMemoryUsage(MonitoringStatistics monStats) {
        if (monStats == null) {
            return Optional.empty();
        }

        MemoryStatistics memStats = monStats.memoryStatistics();

        return Optional.of(
            new DeviceMemoryStats(memStats.free(), memStats.used(), memStats.total()));
    }

}