// $Id: RoutingTable.java,v 1.14 2007/11/08 07:14:17 zahorjan Exp $

import java.util.*;

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

/**
 * For simplicity, there is only one routing table class.  It keeps
 * next-hop information, which they all do.  It also keeps distance
 * to the destination, which not all need or do.
 * <p>
 * These routing tables can create a vector of changes made to them.
 * This is useful in sending 'diffs' around in update packets.
 */

public class RoutingTable {

    /**
     * A class encapsulated the notion of a routing table entry.
     */
    public class Entry {
        public Node nextHop;
        public int dist;

        public Entry() {
            nextHop = null;
            dist = ConstAlg.INFINITY;
        }
        /**
         * Copy constructor.
         */
        public Entry(Entry other) {
            this.nextHop = other.nextHop;
            this.dist = other.dist;
        }
    }

    /**
     * The actual routing table.
     */
    protected Entry[] table;

    /**
     * A class representing a single log entry.
     */
    class LogEntry {
        public Node dest;
        public int dist;

        public LogEntry(Node d) {
            dest = d;
            dist = table[dest.getUID()].dist;
        }
    }

    /**
     * The 'diff' log used to record changes to the table.
     */
    protected Vector<LogEntry> log;
    /**
     * Controls whether or not logging is performed.
     */
    protected boolean doLog;
    /**
     * Indicates whether or not an entry has been written since
     * startLog() was called.
     */
    private boolean[] changed;

    /**
     * Returns the number of entries in the routing table.
     */
    public int size() { return table.length; }

    /**
     * Indicate that want to keep log of changes starting now.
     */
    public void startLog() {
        log = null;  // get rid of any old log
        for ( int n=0; n<changed.length; n++) changed[n] = false;
        doLog = true;
    }
    /**
     * Turn off logging.
     */
    public void stopLog() {
        doLog = false;
    }
    /**
     * Returns true if table is currently logging changes, false otherwise.
     */
    public boolean isLogging() { return doLog; }
    /**
     * Accessor for log.
     */
    public Vector<LogEntry> getLog() { 
        // if the log doesn't exist, create it
        if ( log == null ) {
            log = new Vector<LogEntry>();
            for ( int n=0; n<changed.length; n++) {
                if ( changed[n] ) log.add(new LogEntry(Network.getNetwork().getNodeArray()[n]));
            }
        }
        return log;
    }
        
    public Node getHopTo(Node dest)  { return table[dest.getUID()].nextHop; }
    public int getDistTo(Node dest) { return table[dest.getUID()].dist; }

    /**
     * Routing tables are always the size of the number of nodes in
     * the sole Network object that exists.
     */
    public RoutingTable() {
        doLog = false;
        int nnodes = Network.getNetwork().numNodes();
        table = new Entry[nnodes];
        changed = new boolean[nnodes];
        for (int n=0; n<nnodes; n++) {
            table[n] = new Entry();
            table[n].nextHop = null;
            table[n].dist = ConstAlg.INFINITY;
        }
    }

    /**
     * Sets an entry -- both next hop and distance.
     */
    public void setEntry(Node dest, Node next, int d) {
        table[dest.getUID()].nextHop = next;
        table[dest.getUID()].dist = d;
        addLogEntry(dest);
    }

    /**
     * Adds an entry to the log.
     */
    public void addLogEntry(Node dest) {
        if ( doLog )changed[dest.getUID()] = true;
    }

    /**
     * Eliminates all entries that have the given node as their next hop,
     * and makes distance to the destination infinite.
     */
    public void clearTableOf(Node badNode) {
        for ( int n=0; n<size(); n++) {
            if ( table[n].nextHop == badNode ) cleanEntry(n);
        }
    }

    /**
     * Sets an individual entry to unreachable.
     */
    private void cleanEntry(int index) {
        setEntry(Network.getNetwork().getNodeArray()[index], null, ConstAlg.INFINITY);
    }

    /**
     * Clears out the table -- throws away all next hop information and
     * and log info that might exist, and turns off logging.
     */
    public void cleanTable() {
        // we clean the log in a peculiar way...
        stopLog();  // turn off logging if it's on
        startLog(); // cleans the log as a side effect
        stopLog();  // logging should be off when we exit

        // now erase all entries
        for (int n=0; n<size(); n++ ) {
            table[n].nextHop = null;
            table[n].dist = ConstAlg.INFINITY;
        }
    }


    public String toString() {
        String result = "";
        for (int n=0; n<size(); n++) {
            result += "\t" + n + "\t" + table[n].nextHop + " (" +
                table[n].dist + ")\n";
        }
        return result;
    }
}