#include <iostream>
#include <vector>
#include <list>
#include <assert.h>
#include <map>
#include <queue>
#include <stack>

using namespace std;
#include "Graph.h"

//Create a graph object with the given nodes
//and initialize the adjacent lists to empty 
template <class NodeType>
Graph<NodeType>::Graph (NodeType nodeArray[], int len, bool d)
{
	for (int i=0;i<len;i++)
	{
			nodes.push_back (nodeArray[i]);

			//Initialize adjacent list of nodes[i] to be an empty list 
			list<int> adjacentList;
			edges.push_back (adjacentList);
	}
	directed = d;

}

//Precondition: from and to nodes are in the vector of nodes 
//
template <class NodeType>
void Graph<NodeType>::AddEdge (const NodeType & from, const NodeType & to)
{
	int cnt=0;
	int fromIndex, toIndex;

	//Find from and to nodes in the nodes vector 
	for (int i=0;i<nodes.size();i++)
	{
			if (nodes[i]==from)
			{
				fromIndex = i;
				cnt++;
			} 
			if (nodes[i]==to)
			{
				toIndex = i;
				cnt++;
			}

	}

	//check precondition
	assert (cnt==2);

	edges[fromIndex].push_back(toIndex);
	if (!directed) 
		edges[toIndex].push_back (fromIndex);
		
}

//return the adjacent list of node u 
template <class NodeType>
list<int> Graph<NodeType>::AdjacentNodes (const NodeType & u)
{
	for (int i=0;i<nodes.size();i++)
        {
              if (nodes[i]==u)
	   	return edges[i]; 
        }

	//We shouldn't be here... as node u should be a node in the graph 
	assert (false);
}

template <class NodeType> 
int Graph<NodeType>::FindNode (const NodeType & u)
{
	for (int i=0;i<nodes.size();i++)
        {
                 if (nodes[i]==u)
		    return i;
        }

}

template <class NodeType> 
void Graph<NodeType>::Display()
{
       list<int>::iterator it;

	if (directed) 
		cout <<"Directed Graph:\n";
	else
		cout <<"Undirected Graph:\n";

	cout <<"Vertex: {";

	for (int i=0;i<nodes.size();i++)
	{
		cout <<nodes[i]<<"(degree="<<edges[i].size()<<") ";
	}
	cout <<"}"<<endl;

	cout <<"Edges:\n{";
	for (int i=0;i<nodes.size();i++)
	{
		for (it=edges[i].begin();it!=edges[i].end();it++)
			if (directed) 
				cout <<"   " <<nodes[i]<<"->"<<nodes[*it]<<","<<endl;
			else
			{
				if (i<=(*it))
					cout <<"   " <<nodes[i]<<"-"<<nodes[*it]<<","<<endl;
			}
	}
	cout <<"}\n";

}

//Explore and visit all vertices of the graph that are
//reachable from node s in BFS order
// When finish: Display
//     * the depth of all reachable vertices (i.e., shortest distance to s)
//     * the predecessors of all reachable vertices (BFS tree)
template<class NodeType>
void Graph<NodeType>::BFS_Explore (NodeType s)
{
	typedef enum Color{
		White=0, 
		Gray=1, 
		Black=2} Color;
	map<NodeType,int> d; //the depth/hop count of all nodes from s
	map<NodeType,NodeType> pred; // pred[u] is the node that leads us to u 
	map<NodeType,Color> color; //color[u] will be White, Gray, Black
	queue<NodeType> Q;

	// initialize all nodes to white
	for (int i=0;i<nodes.size();i++)
	{
		color[nodes[i]]=White;
		d[nodes[i]]=99999;
	}

	//source node init
	color[s]=Gray;
	d[s]=0;
	//insert s into Q
	Q.push(s);

	//While-loop...
	while (Q.size()!=0){
		//get the node in the front of queue
		NodeType u=Q.front();
		Q.pop();

		//For each node v in Adjacency list of u
		// if it's white, do .... 
		list<int> adjNodes = AdjacentNodes (u);
		for (int j:adjNodes){
			NodeType v=nodes[j];

			if (color[v]==White)
			{
				color[v]=Gray;
				d[v]=d[u]+1;
				pred[v]=u;
				Q.push(v);
			}
		}
		color[u]=Black;

	}

	//Display color, depth, predecessor 
	for (int i=0;i<nodes.size();i++)
	{
		cout <<"Node " << nodes[i]<< " is ";
		if (color[nodes[i]]==White)
			cout <<" white ";
		else if (color[nodes[i]]==Gray)
			cout <<" gray ";
		else if (color[nodes[i]]==Black)
			cout <<" black ";
		cout <<". depth is " << d[nodes[i]];
		cout <<". Predecessor is "<< pred[nodes[i]]<<endl;
	}


}