var table, k, t = 50, area = 1450 * 1450;
var vertices = {}, edges = [];
var vDispX, vDispY, dx, dy, v1, v2;

function preload() {
    table = loadTable('0.edges');
}

function setup() {

    createCanvas(1500, 1500);
    var row, pair;

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

        if (!(pair[0] in vertices))
            vertices[pair[0]] = new Vertex(pair[0]);

        if (!(pair[1] in vertices))
            vertices[pair[1]] = new Vertex(pair[1]);

        edges.push(new Edge(pair[0], pair[1]));
    }

    k = sqrt(area / Object.keys(vertices).length);
}

function draw(){
    clear();

    var dx, dy, v1, v2;

    for (var j = 0; j < 20; j++) {
        for (var v in vertices) {
            var vDispX = 0;
            var vDispY = 0;
            for (var u in vertices) {
                if (vertices[v].getNum() != vertices[u].getNum()) {

                    diffVectorX1(dx);
                    diffVectorY1(dy);
                    notZero(dx, dy);
                    deltavDispXRepul(vDispX);
                    deltavDispYRepul(vDispY);

                    function diffVectorX1(x){
                        return vertices[v].getX() - vertices[u].getX();
                    }

                    function diffVectorY1(y){
                        return vertices[v].getY() - vertices[u].getY();
                    }

                    function deltavDispXRepul(x){
                        return vDispX + ((dx/abs(dx)) * repulsive(abs(dx)));
                    }
                    function deltavDispYRepul(y){
                        return vDispY + ((dy/abs(dy)) * repulsive(abs(dy)));
                    }

                    function notZero(x,y){
                        if (dx != 0) {
                            return dx;
                        } else {
                            return 0.01;
                        }

                        if (dy !=0){
                            return dy;
                        } else{
                            return 0.01;
                        }
                    }
                }
            }

            vertices[v].setdispx(vDispX);
            vertices[v].setdispy(vDispY);
        }

        var evDispX, evDispY, euDX, euDY;

        // cool/temp control
        for (var i = 0; i < edges.length; i++){
            v1 = edges[i].getV1();
            v2 = edges[i].getV2();

            evDispX = vertices[v1].getdispx();
            evDispY = vertices[v1].getdispy();
            euDX = vertices[v2].getdispx();
            euDY = vertices[v2].getdispy();


            diffVectorX2(dx);
            diffVectorY2(dy)
            notZero(dx, dy);
            evDeltaDXAttract(evDispX);
            evDeltaDYAttract(evDispY);
            euDeltaDXAttract(euDX);
            euDeltaDYAttract(euDY)

            vertices[v1].setdispx(evDispX);
            vertices[v1].setdispy(evDispY);
            vertices[v2].setdispx(euDX);
            vertices[v2].setdispy(euDY);

            function diffVectorX2(x){
                return vertices[v1].getX() - vertices[v2].getX();
            }

            function diffVectorY2(y){
                return vertices[v1].getY() - vertices[v2].getY();
            }

            function evDeltaDXAttract(x){
                return evDispX - ((dx/abs(dx))*attractive(abs(dx)));
            }

            function evDeltaDYAttract(x){
                return evDispY - ((dy/abs(dy))*attractive(abs(dy)));
            }

            function euDeltaDXAttract(x){
                return euDX + ((dx/abs(dx))*attractive(abs(dx)));
            }

            function euDeltaDYAttract(x){
                return euDY + ((dy/abs(dy))*attractive(abs(dy)));
            }


            function notZero(x,y){
                if (vDispX != 0) {
                    return vDispX;
                } else {
                    return 0.01;
                }

                if (vDispY !=0){
                    return vDispY;
                } else{
                    return 0.01;
                }
            }
        }

        var vPositinX, vPostionY, vDispX, vDispY;
        //  limiting max displacement to temperature t to prevent from displacement out of frame
        for (v in vertices){
            vPositinX = vertices[v].getX();
            vPostionY = vertices[v].getY();
            vDispX = vertices[v].getdispx();
            vDispY = vertices[v].getdispy();

            notZero(vDispX, vDispY)

            vPositionX(vPositinX);
            vPositionY(vPostionY);
            vPosXMin(vPositinX);
            vPosYMin(vPositionY);

            vertices[v].setX(vPositinX);
            vertices[v].setY(vPostionY);

            function vPosXMin(x){
                return min(1450, max(50, vPositinX));
            }

            function vPosYMin(y){
                return min(1450, max(50, vPositionY));
            }

            function vPositionX(v){
                return vPositinX + ((vDispX/abs(vDispX)) * min(abs(vDispX), t));
            }

            function vPositionY(v){
                return vPostionY +((vDispY/abs(vDispY)) * min(abs(vDispY), t));
            }


            function notZero(x,y){
                if (dx != 0) {
                    return dx;
                } else {
                    return 0.01;
                }

                if (dy !=0){
                    return dy;
                } else{
                    return 0.01;
                }
            }

        }

        t = cool(t)
    }

    var hover = 1;
    for (var j = 0; j <edge.length; j++)
        edges[j].show();

}


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

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

function cool(t){
    return t * .9;
}



class Vertex {

    constructor(id){
        this.id = id;
        this.x = random(50, 1450);
        this.y = random(50, 1450);
        this.vDispX = 0;
        this.vDispY = 0;
    }

    getNum(){
        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);
    }
    
}

class Edge {

    constructor(v1, v2){
        this.v1 = v1;
        this.v2 = v2;
    }

    getV1(){
        return this.v1;
    }

    getV2(){
        return this.v2;
    }

    show(){
        var x1 = vertices[this.v1].getX();
        var y1 = vertices[this.v1].getY();
        var x2 = vertices[this.v2].getX();
        var y2 = vertices[this.v2].getY();
        strokeWeight(0.5);
        stroke(100);
        line(x1, y1, x2, y2);
    }
}