var table, k, t = 50;
var edges = [];
var vertices = {};
var area = 950*950;

function preload() {

  table = loadTable('698.edges');
}

function setup() {

	createCanvas(1000,1000);
	var str, parsed;

	// calculate number of vertices, and add edges

	for (var i =0; i < table.getRowCount(); i++){
		str = table.getString(i,0);
		parsed = str.split(" ");

		// read in vertices and add to map of vertices
		// also check for min and max

		if (!(parsed[0] in vertices)){
			vertices[parsed[0]] = new Vertice(parsed[0]);
		}

		if (!(parsed[1] in vertices)){
			vertices[parsed[1]] = new Vertice(parsed[1]);
		}

		// add edges to edges array
		edges.push(new Edge(parsed[0], parsed[1]));
	}
	k = sqrt(area/Object.keys(vertices).length);
	
} // end setup

function draw(){
	clear();
	
	var vdispx, vdispy, distx, disty, v1, v2, evdispx, evdispy, eudispx, evdispy;
	for (var j = 0; j < 20; j++){
		for (var v in vertices){
			vdispx = 0;
			vdispy = 0;
			for (var u in vertices){
				if (vertices[v].getID() != vertices[u].getID()){
					// distance vector between two vertices
					distx = vertices[v].getX() - vertices[u].getX();
					disty = vertices[v].getY() - vertices[u].getY();

					if (distx == 0){
						distx = 0.00001;
					}

					if (disty == 0){
						disty = 0.00001;
					}
					vdispx = vdispx + ((distx/abs(distx)) * repulsive(abs(distx)));
					vdispy = vdispy + ((disty/abs(disty)) * repulsive(abs(disty)));
					
				}
			}
			vertices[v].setdispx(vdispx);
			vertices[v].setdispy(vdispy);

		}

		
		for (var i = 0; i < edges.length; i++){
				v1 = edges[i].getVertice1();
				v2 = edges[i].getVertice2();

				evdispx = vertices[v1].getdispx();
				evdispy = vertices[v1].getdispy();
				eudispx = vertices[v2].getdispx();
				eudispy = vertices[v2].getdispy();

				distx = vertices[v1].getX() - vertices[v2].getX();
				disty = vertices[v1].getY() - vertices[v2].getY();

				if (distx == 0){
					distx = 0.00001;
				}

				if (disty == 0){
					disty = 0.00001;
				}

				evdispx = evdispx - ((distx/abs(distx))*attractive(abs(distx)));
				evdispy = evdispy - ((disty/abs(disty))*attractive(abs(disty)));

				eudispx = eudispx + ((distx/abs(distx))*attractive(abs(distx)));
				eudispy = eudispy + ((disty/abs(disty))*attractive(abs(disty)));

				vertices[v1].setdispx(evdispx);
				vertices[v1].setdispy(evdispy);
				vertices[v2].setdispx(eudispx);
				vertices[v2].setdispy(eudispy);
				
		}

			var vposx, vposy, vdispx, vdispy;
			for (v in vertices){

				vposx = vertices[v].getX();
				vposy = vertices[v].getY();
				vdispx = vertices[v].getdispx();
				vdispy = vertices[v].getdispy();

				if (vdispx == 0){
					vdispx = 0.0001;
				}
				if (vdispy == 0){
					vdispy = 0.0001;
				}

				vposx = vposx + ((vdispx/abs(vdispx)) * min(abs(vdispx), t));
				vposy = vposy + ((vdispy/abs(vdispy)) * min(abs(vdispy), t));

				vposx = min(950, max(50, vposx)); 
				vposy = min(950, max(50, vposy));

				vertices[v].setX(vposx);
				vertices[v].setY(vposy);

			}
			t = t*0.9;
		}
		 

	var isHover = -1; 

	for (var j = 0; j < edges.length; j++){
		edges[j].show();
	}

	for (v in vertices){
		vertices[v].show();
		if (vertices[v].checkHover()){
			isHover = v;
		}
	}

	if (isHover != -1){
		vertices[isHover].getDetails();
	}
}


function attractive(x){
	return sq(x)/k;
}

function repulsive(x){
	return sq(k)/x;
}

class Vertice {

	constructor(id){
		this.id = id;
		// randomly assign position
		this.x = random(50, 950);
		this.y = random(50, 950);
		this.vdispx = 0;
		this.vdispy = 0;
	}

	getID(){
		return this.id;
	}

	getX(){
		return this.x;
	}
	
	getY(){
		return this.y;
	}

	setdispx(vdispx){
		this.vdispx = vdispx;
	}

	setdispy(vdispy){
		this.vdispy = vdispy;
	}

	getdispx(){
		return this.vdispx;
	}

	getdispy(){
		return this.vdispy;
	}

	setX(x){
		this.x = x;
	}

	setY(y){
		this.y = y;
	}

	show(){
		fill(0);
		ellipse(this.x, this.y, 4);
	}

	checkHover(){
		var distance = dist(this.x, this.y, mouseX, mouseY);
		if (distance < 4){
			return true;
		} 
		else{
			return false;
		}
	}

	getDetails(){
		fill('red');
		ellipse(this.x, this.y, 4);
		text(this.id, this.x+10, this.y+10);
		for (var i = 0; i < edges.length; i++){
			if (parseInt(edges[i].getVertice1()) == parseInt(this.id) || parseInt(edges[i].getVertice2()) == parseInt(this.id)){
				edges[i].show2();
			}
		}
	}


}

class Edge {

	constructor(vertice1, vertice2){
		this.vertice1 = vertice1;
		this.vertice2 = vertice2;
	}

	show(){
		var x1 = vertices[this.vertice1].getX();
		var y1 = vertices[this.vertice1].getY();
		var x2 = vertices[this.vertice2].getX();
		var y2 = vertices[this.vertice2].getY();
		strokeWeight(1);
		stroke(200);
		line(x1, y1, x2, y2);

	}

	show2(){
		var x1 = vertices[this.vertice1].getX();
		var y1 = vertices[this.vertice1].getY();
		var x2 = vertices[this.vertice2].getX();
		var y2 = vertices[this.vertice2].getY();
		strokeWeight(1);
		stroke(100);
		line(x1, y1, x2, y2);

	}

	getVertice1(){
		return this.vertice1;
	}

	getVertice2(){
		return this.vertice2;
	}
}