/*
 * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */

package org.opendaylight.controller.protocol_plugin.openflow.internal;

import java.util.Collections;
import java.util.Date;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.felix.dm.Component;
import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimInternalListener;
import org.opendaylight.controller.protocol_plugin.openflow.IOFInventoryService;
import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.opendaylight.controller.sal.core.ConstructionException;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.core.Node.NodeIDType;
import org.opendaylight.controller.sal.core.NodeConnector;
import org.opendaylight.controller.sal.core.Property;
import org.opendaylight.controller.sal.core.TimeStamp;
import org.opendaylight.controller.sal.core.Tables;
import org.opendaylight.controller.sal.core.Actions;
import org.opendaylight.controller.sal.core.Buffers;
import org.opendaylight.controller.sal.core.Capabilities;
import org.opendaylight.controller.sal.core.UpdateType;
import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
import org.opendaylight.controller.sal.utils.GlobalConstants;

/**
 * The class describes inventory service protocol plugin. One instance per
 * container of the network. Each instance gets container specific inventory
 * events from InventoryServiceShim. It interacts with SAL to pass inventory
 * data to the upper application.
 *
 *
 */
public class InventoryService implements IInventoryShimInternalListener,
        IPluginInInventoryService, IOFInventoryService {
    protected static final Logger logger = LoggerFactory
            .getLogger(InventoryService.class);
    private Set<IPluginOutInventoryService> pluginOutInventoryServices = Collections
            .synchronizedSet(new HashSet<IPluginOutInventoryService>());
    private IController controller = null;
    private ConcurrentMap<Node, Map<String, Property>> nodeProps; // properties are maintained in default container only
    private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps; // properties are maintained in default container only
    private boolean isDefaultContainer = false;

    void setController(IController s) {
        this.controller = s;
    }

    void unsetController(IController s) {
        if (this.controller == s) {
            this.controller = null;
        }
    }

    /**
     * Function called by the dependency manager when all the required
     * dependencies are satisfied
     *
     */
    @SuppressWarnings("rawtypes")
    void init(Component c) {
        logger.trace("INIT called!");

        Dictionary props = c.getServiceProperties();
        if (props != null) {
            String containerName = (String) props.get("containerName");
            isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
                    .toString());
        }

        nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
        nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
    }

    /**
     * Function called by the dependency manager when at least one dependency
     * become unsatisfied or when the component is shutting down because for
     * example bundle is being stopped.
     *
     */
    void destroy() {
        logger.trace("DESTROY called!");
    }

    /**
     * Function called by dependency manager after "init ()" is called and after
     * the services provided by the class are registered in the service registry
     *
     */
    void start() {
        logger.trace("START called!");
    }

    /**
     * Function called by the dependency manager before the services exported by
     * the component are unregistered, this will be followed by a "destroy ()"
     * calls
     *
     */
    void stop() {
        logger.trace("STOP called!");
    }

    public void setPluginOutInventoryServices(IPluginOutInventoryService service) {
        logger.trace("Got a service set request {}", service);
        if (this.pluginOutInventoryServices != null) {
            this.pluginOutInventoryServices.add(service);
        }
    }

    public void unsetPluginOutInventoryServices(
            IPluginOutInventoryService service) {
        logger.trace("Got a service UNset request");
        if (this.pluginOutInventoryServices != null) {
            this.pluginOutInventoryServices.remove(service);
        }
    }

    protected Node OFSwitchToNode(ISwitch sw) {
        Node node = null;
        Object id = sw.getId();

        try {
            node = new Node(NodeIDType.OPENFLOW, id);
        } catch (ConstructionException e) {
            e.printStackTrace();
        }

        return node;
    }

    /**
     * Retrieve nodes from openflow
     */
    @Override
    public ConcurrentMap<Node, Map<String, Property>> getNodeProps() {
        if (nodeProps == null)
            return null;
        Map<Long, ISwitch> switches = controller.getSwitches();
        for (Map.Entry<Long, ISwitch> entry : switches.entrySet()) {
        	ISwitch sw = entry.getValue();
            Node node = OFSwitchToNode(sw);
            Map<String, Property> propMap = null;
            if (isDefaultContainer) {
                propMap = new HashMap<String, Property>();
                byte tables = sw.getTables();
                Tables t = new Tables(tables);
                if (t != null) {
                	propMap.put(Tables.TablesPropName,t);
                }
                int cap = sw.getCapabilities();
                Capabilities c = new Capabilities(cap);
                if (c != null) {
                	propMap.put(Capabilities.CapabilitiesPropName, c);
                }
                int act = sw.getActions();
                Actions a = new Actions(act);
                if (a != null) {
                	propMap.put(Actions.ActionsPropName,a);
                }
                int buffers = sw.getBuffers();
                Buffers b = new Buffers(buffers);
                if (b != null) {
                	propMap.put(Buffers.BuffersPropName,b);
                }
                Date connectedSince = sw.getConnectedDate();
                Long connectedSinceTime = (connectedSince == null) ? 0
                        : connectedSince.getTime();
                TimeStamp timeStamp = new TimeStamp(connectedSinceTime,
                        "connectedSince");
                propMap.put(TimeStamp.TimeStampPropName, timeStamp);
                nodeProps.put(node, propMap);
            }
        }
        return nodeProps;
    }

    @Override
    public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
            Boolean refresh) {
        if (nodeConnectorProps == null)
            return null;

        if (isDefaultContainer && refresh) {
            Map<Long, ISwitch> switches = controller.getSwitches();
            for (ISwitch sw : switches.values()) {
                Map<NodeConnector, Set<Property>> ncProps = InventoryServiceHelper
                        .OFSwitchToProps(sw);
                for (Map.Entry<NodeConnector, Set<Property>> entry : ncProps
                        .entrySet()) {
                    updateNodeConnector(entry.getKey(), UpdateType.ADDED, entry
                            .getValue());
                }
            }
        }

        return nodeConnectorProps;
    }

    @Override
    public void updateNodeConnector(NodeConnector nodeConnector,
            UpdateType type, Set<Property> props) {
        logger.trace("NodeConnector id " + nodeConnector.getID()
                + " type " + nodeConnector.getType() + " "
                + type.getName() + " for Node id "
                + nodeConnector.getNode().getID());

        if (nodeConnectorProps == null)
            return;

        synchronized (nodeConnectorProps) {
            Map<String, Property> propMap = nodeConnectorProps
                    .get(nodeConnector);
            switch (type) {
            case ADDED:
            case CHANGED:
                if (propMap == null)
                    propMap = new HashMap<String, Property>();

                if (props != null) {
                    for (Property prop : props) {
                        propMap.put(prop.getName(), prop);
                    }
                }
                nodeConnectorProps.put(nodeConnector, propMap);
                break;
            case REMOVED:
                nodeConnectorProps.remove(nodeConnector);
                break;
            default:
                return;
            }
        }

        // update sal and discovery
        synchronized (pluginOutInventoryServices) {
            for (IPluginOutInventoryService service : pluginOutInventoryServices) {
                service.updateNodeConnector(nodeConnector, type, props);
            }
        }
    }

    private void addNode(Node node, Set<Property> props) {
        logger.trace("{} added", node);
        if (nodeProps == null)
            return;

        // update local cache
        Map<String, Property> propMap = new HashMap<String, Property>();
        for (Property prop : props) {
            propMap.put(prop.getName(), prop);
        }
        nodeProps.put(node, propMap);

        // update sal
        synchronized (pluginOutInventoryServices) {
            for (IPluginOutInventoryService service : pluginOutInventoryServices) {
                service.updateNode(node, UpdateType.ADDED, props);
            }
        }
    }

    private void removeNode(Node node) {
        logger.trace("{} removed", node);
        if (nodeProps == null)
            return;

        // update local cache
        nodeProps.remove(node);

        Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
        for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
            if (nodeConnector.getNode().equals(node)) {
                removeSet.add(nodeConnector);
            }
        }
        for (NodeConnector nodeConnector : removeSet) {
            nodeConnectorProps.remove(nodeConnector);
        }

        // update sal
        synchronized (pluginOutInventoryServices) {
            for (IPluginOutInventoryService service : pluginOutInventoryServices) {
                service.updateNode(node, UpdateType.REMOVED, null);
            }
        }
    }

    /*
     * Function called by other protocol plugin modules to notify Inventory Service
     * that a property has changed for the specified switch
     */
    @Override
    public void updateSwitchProperty(Long switchId, Set<Property> propSet) {
        // update local cache
        Node node = OFSwitchToNode(controller.getSwitches().get(switchId));
        Map<String, Property> propMap = nodeProps.get(node);
        if (propMap == null)
            propMap = new HashMap<String, Property>();
        for (Property prop : propSet) {
            propMap.put(prop.getName(), prop);
        }
        nodeProps.put(node, propMap);

        // update sal
        synchronized (pluginOutInventoryServices) {
            for (IPluginOutInventoryService service : pluginOutInventoryServices) {
                service.updateNode(node, UpdateType.CHANGED, propSet);
            }
        }
    }

    @Override
    public void updateNode(Node node, UpdateType type, Set<Property> props) {
        switch (type) {
        case ADDED:
            addNode(node, props);
            break;
        case REMOVED:
            removeNode(node);
            break;
        default:
            break;
        }
    }
}