// $Id: Network.java,v 1.31 2007/11/08 01:57:01 zahorjan Exp $

import java.util.*;
import java.io.*;

import org.jgrapht.*;
import org.jgrapht.graph.*;

/**
 * Class representing an entire network.
 */

public class Network extends SimpleGraph<Node,DefaultEdge>
{
    /**
     * Used by getNetwork().
     */
    private static Network theNetwork = null;
    /**
     * There can be only one network in an application.
     * There is a static accessor function to find it.
     */
    public static Network getNetwork() { return theNetwork; }

    /**
     * An array of all nodes in the network.
     */
    private Node[] node;

    /**
     * Set to true if the topology changes because
     * one or more nodes fail or recover.  Reset to false
     * by takeStep().
     */
    private boolean hasChanged;

    private MyRandom rand;
    private int nNodes = 0;
    private int nEdges = 0;

    public Node[] getNodeArray() { return node; }

    // the values returned include any failed nodes and their edges
    public int numNodes() { return nNodes; }
    public int numEdges() { return nEdges; }

    /**
     * Returns true if the network has changed (nodes added or deleted)
     * since the last invocation of takeStep(), false otherwise.
     */
    public boolean hasChanged() { return hasChanged; }

    /**
     * Constructor leading to a randomly generated topology.  First construct
     * the network object, then call initialize(). 
     * <p>
     * There can be at most one Network object in the application.
     * An IllegalStateException is thrown otherwise.
     */
    public Network(int nnodes, int nedges, VertexFactory<Node> nodeFactory )
        throws IllegalArgumentException, IllegalStateException 
    {
        super(DefaultEdge.class);

        nNodes = nnodes;
        nEdges = nedges;

        commonInit();

        // sanity check args
        if ( nnodes < 1 || nedges < nnodes-1 ||
             nedges > (nnodes*(nnodes-1))/2 ) {
            throw new IllegalArgumentException( 
                                 "Bad arguments to Network constructor("  +
                                 nnodes + ", " + nedges + ")"
                               );
        }

        // Now construct the random topology.

        // First create a chain, so we know graph is connected.
        // Then add additional edges, at random.

        node[0] = nodeFactory.createVertex();
        addVertex( node[0] );
        for (int n=1; n<nNodes; n++) {
            node[n] = nodeFactory.createVertex();
            addVertex( node[n] );
            addEdge( node[n], node[n-1] );
        }

        // Now add additional edges, if any are required
        for (int e=nNodes-1; e<nEdges; e++) {
            int s = 0;
            int d = 0;
            while ( s==d || containsEdge(node[s], node[d]) ) {
                s = rand.nextInt(nNodes);
                d = rand.nextInt(nNodes);
            }
            addEdge( node[s], node[d] );
        }
    }

    /**
     * Constructor that generates the Network using a description in a file.
     * The file format is the number of nodes (as an integer) on the first line,
     * followed by edges given as source/destination node numbers
     * (nodes are numbered 0, 1, ... , #nodes-1):
     * <pre>
     *   #nodes
     *   src dst
     *   src dst
     *   ...
     * </pre>
     * <p>
     * First construct the network object, then call initialize(). 
     * <p>
     * There can be at most one Network object in the application.
     * An IllegalStateException is thrown otherwise.
     */
    public Network(String graphFile, VertexFactory<Node> nodeFactory )
        throws IllegalStateException, FileNotFoundException, IOException
    {
        super(DefaultEdge.class);

        // prepare to read the file -- get #nodes
        FileInputStream inStream = new FileInputStream(graphFile);
        Scanner scanner = new Scanner(inStream);
        nNodes = scanner.nextInt();

        // now that we know how many nodes there are we can all commonInit()
        commonInit();

        // create the nodes
        for (int n=0; n<nNodes; n++) {
            node[n] = nodeFactory.createVertex();
            addVertex( node[n] );
        }

        // create the edges
        nEdges = 0;
        while (scanner.hasNextInt()) {
            int src = scanner.nextInt();
            int dst = scanner.nextInt();
            addEdge( node[src], node[dst] );
            nEdges++;
        }

        inStream.close();
    }

    /**
     * Private method for code common to all constructors.
     */
    private void commonInit() throws IllegalStateException
    {
        if ( theNetwork != null ) {
            throw new IllegalStateException("Attempt to create a Network object when one already exists.");
        }
        theNetwork = this;

        hasChanged = false;
        node = new Node[nNodes];
        rand = new MyRandom();
    }

    /**
     * This method MUST BE invoked after construction to finalize
     * creation of the Network object.  (For reasons of implementation
     * detail what is done here cannot be done in the constructors.)
     */
    public void initialize() {

        // Establish the routing tables for all nodes, using an oracle's view
        // (i.e., completely accurate) of the network connectivity.
        for ( Node n : node ) {
            n.oracleComputeRoutingTable();
            n.setupNeighborInformation();
        }

        hasChanged = true;
    }

    /**
     * Mark a node as non-operational. The node is removed from the SimpleGraph
     * that the Network object is.
     * <br>Returns prior failed status of node (i.e., true if it was already failed).
     */
    public boolean failNode(int n) {
        return node[n].setHasFailed( true );
    }

    /**
     * Take a time step.  Go throught nodes in a random order, and invoke
     * each node's update routine with only some fixed probability.
     */
    public void takeStep() {

        // reset boolean indicating whether topology has been changed
        int numVertices = vertexSet().size();
        hasChanged = false;

        // Cause each node to swap its current and future in queues.
        // (Not done in the next loop because I have an idea that might cause
        // each node to be run more than once.)
        for (Node next : node ) {
            next.swapInQueues();
        }

        // okay, now cause each node to take a step.  (Skipping nodes,
        // with probability ConstSysProperties.UPDATE_PROB, is done in the Node code.)
        for ( Node next : node ) {
            next.takeStep();
        }

        // topology changes iff number of vertices has changed
        hasChanged = numVertices != vertexSet().size();
    }

}