package wikigraph;

import java.util.HashMap;

import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Path;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.RelationshipType;
import org.neo4j.graphdb.traversal.Evaluators;
import org.neo4j.graphdb.traversal.TraversalDescription;
import org.neo4j.graphdb.traversal.Traverser;
import org.neo4j.kernel.Traversal;
import org.neo4j.tooling.GlobalGraphOperations;

import wikigraph.Neo4jTest.RelTypes;

public class LinkToNode {

	GraphDatabaseService graphDb;
	GlobalGraphOperations graphOpe;

	public final static String PAGE_TITLE = "page_title";
	public final static String PAGE_RANK = "page_rank";
	private HashMap<String, Long> pageIdTable = new HashMap<String, Long>();
	private HashMap<String, Double> pageRankTable = new HashMap<String, Double>();

	private HashMap<String, WikiPage> wikiPageHash = new HashMap<String, WikiPage>();
	private long AllNodeNumber;

	private final double weight1 = 0.85;
	private final double weight2 = 0.15;

	public enum RelTypes implements RelationshipType {
		HAS_LINK
	}

	LinkToNode(GraphDatabaseService graphDb) {
		this.graphDb = graphDb;
		this.graphOpe = GlobalGraphOperations.at(graphDb);
		AllNodeNumber = 0;
	}

	LinkToNode(GraphDatabaseService graphDb, GlobalGraphOperations graphOpe) {
		this.graphDb = graphDb;
		this.graphOpe = graphOpe;
		AllNodeNumber = 0;
	}

	void setGraphDb(GraphDatabaseService graphDb) {
		this.graphDb = graphDb;
		this.graphOpe = GlobalGraphOperations.at(graphDb);
		AllNodeNumber = 0;
	}

	Long getId(String pageTitle) {
		return pageIdTable.get(pageTitle);
	}

	boolean isHasLink(Relationship rel) {
		return rel.isType(RelTypes.HAS_LINK);
	}

	private Node createNode() {
		return graphDb.createNode();
	}

	private Node createNodeWithProperty(String key, Object value) {
		Node node = createNode();
		node.setProperty(key, value);
		return node;
	}

	void initAllNodePageRank() {
		for (Node node : graphOpe.getAllNodes()) {
			setPageRank(node, 0.0);
		}
	}

	String getPageTitle(Node node) {
		return (String) node.getProperty(PAGE_TITLE);
	}

	Double getPageRank(Node node) {
		return (Double) node.getProperty(PAGE_RANK);
	}

	Node createNodeWithPageTitle(String pageTitle) {
		Node node = createNodeWithProperty(PAGE_TITLE, pageTitle);
		pageIdTable.put(pageTitle, node.getId());
		return node;
	}

	Node setPageRank(Node node, Double rank) {
		node.setProperty(PAGE_RANK, rank);
		return node;
	}

	Node getNode(String name) {
		long id = pageIdTable.get(name);
		return graphDb.getNodeById(id);
	}
	
	Node getNode(int nodeId) {
		return graphDb.getNodeById(nodeId);
	}

	void setRelationship(Node node1, Node node2, RelTypes type) {
		node1.createRelationshipTo(node2, type);
	}

	void setHasLink(Node node1, Node node2) {
		setRelationship(node1, node2, RelTypes.HAS_LINK);
	}

	long searchAllNodes() {
		AllNodeNumber = 0;
		for (Node n : graphOpe.getAllNodes()) {

			n.setProperty(PAGE_RANK,(double)0.0);

			if (n.hasProperty(PAGE_TITLE) || n.hasProperty(PAGE_RANK)) {
				WikiPage wiki = new WikiPage(n);
				pageIdTable.put((String) n.getProperty(PAGE_TITLE), n.getId());
				pageRankTable.put((String) n.getProperty(PAGE_TITLE),
						(Double) n.getProperty(PAGE_RANK));
				wiki.setInLink(computeInHasLink(n));
				wiki.setOutLink(computeOutHasLink(n));
				wikiPageHash.put((String) n.getProperty(PAGE_TITLE), wiki);
				AllNodeNumber++;
			}
		}
		return AllNodeNumber;
	}

	void searchRegiNodes(Node n) {

		if (n.hasProperty(PAGE_TITLE) || n.hasProperty(PAGE_RANK)) {
			WikiPage wiki = new WikiPage(n);
			pageIdTable.put((String) n.getProperty(PAGE_TITLE), n.getId());
			pageRankTable.put((String) n.getProperty(PAGE_TITLE),
					(Double) n.getProperty(PAGE_RANK));
			wiki.setInLink(computeInHasLink(n));
			wiki.setOutLink(computeOutHasLink(n));
			wikiPageHash.put((String) n.getProperty(PAGE_TITLE), wiki);
			AllNodeNumber++;
		}
	}

	HashMap<String, WikiPage> getWikiPageHash() {
		return wikiPageHash;
	}

	HashMap<String, Long> getPageIdTable() {
		return pageIdTable;
	}

	HashMap<String, Double> getPageRankTable() {
		return pageRankTable;
	}

	public void printAllNodes() {
		for (Node n : graphOpe.getAllNodes()) {
			System.out.println("ID=" + n.getId());
			for (String key : n.getPropertyKeys()) {
				System.out.println(key + "=" + n.getProperty(key));
			}
			Iterable<Relationship> relIter = n
					.getRelationships(RelTypes.HAS_LINK);
			for (Relationship rel : relIter) {
				System.out.println(rel);
			}
			System.out.println("--");
		}

	}

	private Traverser getTraverser(final Node node, final Direction rel) {
		TraversalDescription td = Traversal.description().breadthFirst()
				.relationships(RelTypes.HAS_LINK, rel)
				.evaluator(Evaluators.excludeStartPosition());
		return td.traverse(node);

	}

	public Traverser getOutHasLinkTraverser(final Node node) {
		return getTraverser(node, Direction.OUTGOING);
	}

	public Traverser getInHasLinkTraverser(final Node node) {
		return getTraverser(node, Direction.INCOMING);
	}

	public long computeOutHasLink(final Node node) {
		long count = 0;
		Traverser hasLinkTraverser = getOutHasLinkTraverser(node);
		for (Path hasLinkPath : hasLinkTraverser) {
			if (hasLinkPath.length() > 1)
				break;
			count++;
		}
		return count;
	}

	public long computeInHasLink(final Node node) {
		long count = 0;
		Traverser hasLinkTraverser = getInHasLinkTraverser(node);
		for (Path hasLinkPath : hasLinkTraverser) {
			if (hasLinkPath.length() > 1)
				break;
			count++;
		}
		return count;
	}

	public void searchHasLinkOut(final Node node) {
		int numberOfLinkPages = 0;
		String output = node.getProperty(PAGE_TITLE) + " have link pages:\n";
		Traverser hasLinkTraverser = getOutHasLinkTraverser(node);
		for (Path hasLinkPath : hasLinkTraverser) {
			output += "At depth " + hasLinkPath.length() + " => "
					+ hasLinkPath.endNode().getProperty(PAGE_TITLE) + "\n";
			numberOfLinkPages++;
		}
		output += "Number of link pages: " + numberOfLinkPages + "\n";
		System.out.println(output);
	}

	public double computePageRank(Node node) {
		double sum = 0;
		double pageRank = 0;
		String title = getPageTitle(node);
		WikiPage wiki = wikiPageHash.get(title);

		Traverser hasLinkTraverser = getInHasLinkTraverser(node);
		for (Path hasLinkPath : hasLinkTraverser) {
			if (hasLinkPath.length() > 1)
				break;
			Node n = hasLinkPath.endNode();
			sum += (Double) n.getProperty(PAGE_RANK);
		}
		if (wiki.getOutLink() == 0) {
			pageRank = (double) ((double) 1 / AllNodeNumber * weight2);
		} else {
			pageRank = (double) ((double)sum / wiki.getOutLink() * weight1)
					+ (double) ((double) 1 / AllNodeNumber * weight2);
		}

		wiki.setRank(pageRank);
		node.setProperty(PAGE_RANK, pageRank);
		return pageRank;
	}

}