var polygon;
var lines;
var isFinish=false;
var areaText;
var areaTextRect;
var scale;
var area, perimetr, len;
var contourType = 2;


function initVector(canvas, width, height, points, scaleIn, type){
    contourType = type;
    scale = scaleIn;
    raph = Raphael(canvas, width, height);
    polygon = raph.set();
    lines = raph.set();
    for(var i=0; i<points; i++){
        createLine(-10, -10, -10, -10);
        createPoint(-10, -10);
    }
    areaTextRect = raph.rect(-200, -200, 180, 50);
    areaTextRect.attr({fill: "#FFFFFF", "fill-opacity": "0.9"});
    areaText = raph.text(-100, -100, "Длина:0.0 м.\nПериметр:0.0 м.\nПлощадь:0.0 кв.м.")
    areaText.attr({"text-anchor": "start", "font-size": "12"});
}

var discattr = {fill: "#ff0000", stroke: "none"};
var currentPoint;
var pointsCount = 0;


function setContourType(type){
    contourType = type;
    if(type == 0){
        lines.hide();
    }
    else if(type == 1){
        lines.show();
        if(isFinish){
            lines[pointsCount-1].hide();
        }
    }
    else{
        lines.show();
    }
    editArea();
    areaText.attr({text: "Длина:"+len.toFixed(2)+" м.\nПериметр:"+perimetr.toFixed(2)+" м.\nПлощадь:"+area.toFixed(2)+" кв.м."});
}

function setVectorScale(scaleIn){
    scale = scaleIn;
}

function updateAreaText(x, y){
        areaText.attr({x: x+20, y: y+40, text: "Длина:"+len.toFixed(2)+" м.\nПериметр:"+perimetr.toFixed(2)+" м.\nПлощадь:"+area.toFixed(2)+" кв.м."});
        areaTextRect.attr({x: x+15, y: y+15});
}

function createPoint(x, y, i){
    var point = raph.circle(x, y, 4).attr(discattr);
    point.attr({cx: x, cy: y});

    point.update = function (x, y) {
        tx = this.attr("cx");
        ty = this.attr("cy");
        var X = tx + x,
            Y = ty + y,
            ind = -1;
        for(var i=0;i<pointsCount; i++){
            px = polygon[i].attr("cx");
            py = polygon[i].attr("cy");
            if(Math.abs(tx-px) < 4 && Math.abs(ty - py) < 4){
                ind = i;
                break;
            }
        }
        if(ind > -1){
            var nextLine = lines[ind];
            if(nextLine){
                var path = nextLine.attr("path");
                path[0][1] = X;
                path[0][2] = Y;
                lines[ind].attr({path: path});
            }

            var prevLine;
            var prevIndex;
            if(ind == 0){
                prevIndex = pointsCount -1;
            }
            else{
                prevIndex = ind-1;
            }
            var prevLine = lines[prevIndex];
            if(prevLine){
                var path = prevLine.attr("path");
                path[1][1] = X;
                path[1][2] = Y;
                lines[prevIndex].attr({path: path});
            }
        }

        this.attr({cx: X, cy: Y});
        editArea();
        updateAreaText(X, Y);
    };
    point.drag(move, up);
    point.mouseover(function () {$("#dr").draggable( "option", "disabled", true); this.animate({r: 6}, 50);});
    point.mouseout(function () {$("#dr").draggable( "option", "disabled", false); this.animate({r: 4}, 50);});
    polygon.push(point);
}

function createLine(x1, y1, x2, y2){
    var path = [["M", x1, y1], ["L", x2, y2]];
    var line = raph.path(path).attr({stroke: "hsb(0, .75, .75)", "stroke-width": 2, "stroke-linecap": "round"});
    lines.push(line);
}

function addPoint(x, y){
    if(!isFinish){
        for(var i=0; i<pointsCount; i++){
            px = polygon[i].attr("cx");
            py = polygon[i].attr("cy");
            if(Math.abs(x-px) < 4 && Math.abs(y - py) < 4){
                currentPoint = null;
                return;
            }
        }
        currentPoint = polygon[pointsCount];
        currentPoint.translate(x+10,y+10)
        pointsCount++;
    }
}

function move(dx, dy) {
    this.update(dx - (this.dx || 0), dy - (this.dy || 0));
    this.dx = dx;
    this.dy = dy;
}

function up() {
    this.dx = this.dy = 0;
}

function movePoint(x, y) {
    if(currentPoint){
        var point1 = polygon[pointsCount-1];
        var path = lines[pointsCount-1].attr("path");
        path[0][1] = point1.attr("cx");
        path[0][2] = point1.attr("cy");
        path[1][1] = x;
        path[1][2] = y;
        lines[pointsCount-1].attr({path: path});
        createArea(x, y);
        updateAreaText(x, y);
    }
    else{
        areaText.attr({x: x+20, y: y+40});
        areaTextRect.attr({x: x+15, y: y+15});
    }
}

function finish(){
    var point1 = polygon[pointsCount-1];
    var point2 = polygon[0];
    var path = lines[pointsCount-1].attr("path");
    path[0][1] = point1.attr("cx");
    path[0][2] = point1.attr("cy");
    path[1][1] = point2.attr("cx");
    path[1][2] = point2.attr("cy");
    lines[pointsCount-1].attr({path: path});
    isFinish = true;
    currentPoint = null;
    point2.insertAfter(lines[pointsCount-1]);
    if(contourType != 2){
        lines[pointsCount-1].hide();
    }
    editArea();
    areaText.attr({text: "Длина:"+len.toFixed(2)+" м.\nПериметр:"+perimetr.toFixed(2)+" м.\nПлощадь:"+area.toFixed(2)+" кв.м."});
}

function resetVector(){
    for(var i=0; i<pointsCount; i++){
        polygon[i].attr({cx: -10, cy: -10});
        var path = lines[i].attr("path");
        path[0][1] = -10;
        path[0][2] = -10;
        path[1][1] = -10;
        path[1][2] = -10;
        lines[i].attr({path: path});
    }
    areaText.attr({x: -100, y: -100, text: "Длина:0.0 м.\nПериметр:0.0 м.\nПлощадь:0.0 кв.м."});
    currentPoint = null;
    pointsCount = 0;
    area = 0.0;
    perimetr = 0.0;
    len = 0.0;
    isFinish = false;
}

function editArea(){
    area = 0.0;
    perimetr = 0.0;
    len = 0.0;
    if(contourType == 0) return;
    if(pointsCount > 2){
        var fpx, fpy;
		var px1, py1;
		var px2, py2;

        for(var i=0; i<pointsCount; i++){
            px2 = polygon[i].attr("cx");
            py2 = polygon[i].attr("cy");
            if(i == 0){
                fpx = px1 = px2;
                fpy = py1 = py2;
            }
            else{
                area = area + (px1*py2 - px2*py1);  // x1*y2-x2*y1
                perimetr = perimetr + Math.sqrt((px2-px1)*(px2-px1)+(py2-py1)*(py2-py1));
            }
            px1 = px2;
            py1 = py2;
        }
        area = area + (px1*fpy - fpx*py1);
        if(contourType == 2)
            perimetr = perimetr + Math.sqrt((fpx-px2)*(fpx-px2)+(fpy-py2)*(fpy-py2));
    }
    area = Math.abs(area/2.0)/(7200.0/(scale*2.54))/(7200.0/(scale*2.54));
    perimetr = perimetr/(7200.0/(scale*2.54));
}

function createArea(curx, cury){
    area = 0.0;
    perimetr = 0.0;
    len = 0.0;
    if(contourType == 0) return;
    if(pointsCount > 1){
        var fpx, fpy;
		var px1, py1;
		var px2, py2;

        for(var i=0; i<pointsCount; i++){
            px2 = polygon[i].attr("cx");
            py2 = polygon[i].attr("cy");
            if(i == 0){
                fpx = px1 = px2;
                fpy = py1 = py2;
            }
            else{
                area = area + (px1*py2 - px2*py1);  // x1*y2-x2*y1
                perimetr = perimetr + Math.sqrt((px2-px1)*(px2-px1)+(py2-py1)*(py2-py1));
            }
            px1 = px2;
            py1 = py2;
        }
        area = area + (px2*cury - curx*py2);
        area = area + (curx*fpy - fpx*cury);
        len = Math.sqrt((px2-curx)*(px2-curx)+(py2-cury)*(py2-cury));
        perimetr = perimetr + len;
    }
    else if(pointsCount == 1){
		var px2, py2;
        px2 = polygon[0].attr("cx");
        py2 = polygon[0].attr("cy");
        len = Math.sqrt((px2-curx)*(px2-curx)+(py2-cury)*(py2-cury));
        perimetr = len;
    }
    area = Math.abs(area/2.0)/(7200.0/(scale*2.54))/(7200.0/(scale*2.54));
    perimetr = perimetr/(7200.0/(scale*2.54));
    len = len/(7200.0/(scale*2.54));
}


function scaleObjects(scaleIn, w, h){
    if(pointsCount > 0){
        var k = scale/scaleIn;
        for(var i=0;i<pointsCount; i++){
            px = polygon[i].attr("cx");
            py = polygon[i].attr("cy");
            polygon[i].attr("cx", w/2-(w/2-px)*k);
            polygon[i].attr("cy", h/2-(h/2-py)*k);
            var path = lines[i].attr("path");
            path[0][1] = w/2-(w/2-path[0][1])*k;
            path[0][2] = h/2-(h/2-path[0][2])*k;
            path[1][1] = w/2-(w/2-path[1][1])*k;
            path[1][2] = h/2-(h/2-path[1][2])*k;
            lines[i].attr({path: path});
        }
        scale = scaleIn;
    }
}

function translateObjects(x, y){
    for(var i=0;i<pointsCount; i++){
        px = polygon[i].attr("cx");
        py = polygon[i].attr("cy");
        polygon[i].attr("cx", px+x);
        polygon[i].attr("cy", py+y);
        var path = lines[i].attr("path");
        path[0][1] = path[0][1] + x;
        path[0][2] = path[0][2] + y;
        path[1][1] = path[1][1] + x;
        path[1][2] = path[1][2] + y;
        lines[i].attr({path: path});
    }
}