package pythonToJava;

import java.sql.Types;
import java.util.Iterator;
import java.util.List;

import com.hp.hpl.guess.*;
import com.hp.hpl.guess.storage.StorageFactory;

public class Centralizations {
	private static Graph g = Guess.getGraph();

	private static int numNodes = g.getNodes().size();

	private static Schema s = g.getNodeSchema();

	/**
	 * Must be run on an undirected graph.
	 * 
	 * @return the degree centralization for the graph
	 */
	public static double degree() {

		double maxVar = 0.0;
		double var = 0.0;
		maxVar = (numNodes - 1) * (numNodes - 2);
		Iterator it = g.getNodes().iterator();
		((Node) it.next()).__getattr__("totaldegree");
		int max = ((Integer) StorageFactory.getSL().getStatistic(
				s.getField("totaldegree"), "max")).intValue();
		for (final Object o : g.getNodes()) {
			Node node = (Node) o;
			int deg = ((Integer) node.__getattr__("totaldegree")).intValue();
			var += max - deg;
		}
		return var / maxVar;
	}
	
	/**
	 * Only works on undirected, connected graphs.
	 * @param node - Node to find the closness centrality for
	 * @return closness centrality for node
	 */
	public static double closenessCentrality(Node node){
		double total = 0.0;
	    
	    for(final Object o : g.getNodes()){
	    	Node node2 = (Node)o;
	    	List path = node.unweightedShortestPath(node2);
	    	total += path.size();
	    }
	    return (numNodes-1)/(total);
	   
	}
	/**
	 * Finds closeness centralization, only works on undirected, connected graphs
	 * @return closeness centralization of graph
	 */
	public static double closeness(){
		double point = (1.0 - (numNodes-1.0)/(((numNodes-2.0)*2.0)+1.0));
	    double maxVar = (numNodes-1)*point;
	    
	    double var = 0.0;
	    if(s.getField("closeness") == null){
	    	g.addNodeField("closeness", Types.DOUBLE, 0.0);
	    }
	    double maxClose = 0.0;
	    for(final Object o : g.getNodes()){
	    	Node node = (Node)o;
	    	double centrality = closenessCentrality(node);
	    	node.__setattr__("closeness", centrality);
	    	if(centrality > maxClose){
	    		maxClose = centrality;
	    	}
	    }
	    
	    for(final Object o : g.getNodes()){
	    	Node node = (Node) o;
	    	var += (maxClose - ((Double)node.__getattr__("closeness")).doubleValue());
	    }
	   
	   
	    return var/maxVar;
	}
	
	/**
	 * Unsure what graph requirements are; graphs do NOT have to be connected. I would
	 * only run it on undirected graphs at the moment.
	 * @return betweenness centralization
	 */
	public static double betweenness(){
		 
		    double maxVar = ((numNodes -1.0) * (numNodes-2.0))*(numNodes-1);
		    Iterator it = g.getNodes().iterator();
		    ((Node)it.next()).__getattr__("betweenness");
		    
		    double max = ((Double) StorageFactory.getSL().getStatistic(
					s.getField("betweenness"), "max")).doubleValue();
		    double var = 0.0;
		    for(final Object o : g.getNodes()){
		    	Node node = (Node) o;
		    	var += max - ((Double)node.__getattr__("betweenness")).doubleValue();
		    }		    
		    return var/maxVar;
	}

}