/**
 * Implementation of Node for graphs uusing an adjacency list
 * The node definition has been extended to support Dijkstra's shorted path
 * calculations be the addition of  the cost, priorNodes and visited instance variables.
 * 
 * @author  geoffreytowell
 * date Dec 2019
 */
import java.util.ArrayList;

public class Node<E> implements Comparable<Node<E>>
{
    // the "payload" of the node.  For simple implementations this is just an identifier
    private E element;
    
    // the list of edges from the node to implement the adjacency list representation
    private ArrayList<Edge<E>> edges;
    
    // The cost of getting to the node.  Note that cost is only defined with respect to a starting node.
    private int cost;
    
    // the minimum cost path to get to the node -- from a starting node.
    private ArrayList<Edge<E>> priorEdges;
    
    // whether this node has yet been "visited"  
    private boolean visited;
    
    /**
     * Basic contstructor.  Just initializes everything.
     * @param e
     */
    public Node(E e)
    {
	edges = new ArrayList<>();
	element=e;
	cost = 0;
	visited=false;
	priorEdges=new ArrayList<>();;
    }
    
    /**
     * Clear variables to get ready for running dijkstra's algorithm
     */
    public void reset()
    {
	setCost(Integer.MAX_VALUE);
	clearPriorEdges();
	setVisited(false);
    }
    
    /**
     * 
     * @param v
     */
    public void setVisited(boolean v)
    {
	this.visited=v;
    }
    public boolean getVisited()
    {
	return visited;
    }
    public int getCost()
    {
	return cost;
    }
    public void setCost(int c)
    {
	this.cost=c;
    }
    public ArrayList<Edge<E>> getPriorEdges()
    {
	return priorEdges;
    }
    public void addPriorEdge(Edge<E> ed)
    {
	priorEdges.add(ed);
    }
    public void setPriorEdges(ArrayList<Edge<E>> edges)
    {
	clearPriorEdges();
	priorEdges.addAll(edges);
    }
    public void clearPriorEdges()
    {
	priorEdges.clear();
    }
    public ArrayList<Edge<E>> getEdges()
    {
	return edges;
    }
    public E getValue()
    {
	return element;
    }
    public void addEdgeTo(Node<E> too, String id, int cost)
    {
	edges.add(new Edge<E>(this, too, id, cost));
    }
    public void addEdgeTo(Node<E> too, String id)
    {
	edges.add(new Edge<E>(this, too, id));
    }
    public String toString()
    {
	return element.toString();
    }
    @Override
    public int compareTo(Node<E> node)
    {
	return cost-node.getCost();
    }
}