Kinetic.Connect = function(config){
	Kinetic.Group.call(this, config);
	this.data = config.data;
	
	this.initExercise();
	this.createExercise();
	this.eventHandlers();
}
	
Kinetic.Connect.prototype = {
	createExercise: function(){
		// endPoints group
		this.endPointsGroup = new Kinetic.Group({
			'x': this.data.endPointsLocation.x,
			'y': this.data.endPointsLocation.y
		});
		this.add(this.endPointsGroup);
		
		// startPoints group
		this.startPointsGroup = new Kinetic.Group({
			'x': this.data.startPointsLocation.x,
			'y': this.data.startPointsLocation.y
		});
		this.add(this.startPointsGroup);
		
		
		// startPoints
		var startPointData = this.data.startPoints;
		
		var yPos = 0;
		var labelHeight = 0;
		
		this.startPoints = new Array();
		
		for (var i = 0; i < startPointData.length; i++){
			startPointData[i].type = 'startPoint';
			this.startPoints[i] = new Kinetic.ConnectPoint({
				'data': startPointData[i],
				'y': yPos
			});
			this.startPointsGroup.add(this.startPoints[i]);
			
			labelHeight = parseInt(this.startPoints[i].getHeight());
			
			yPos +=  labelHeight + 25;
		}
		
		
		// endPoints
		var endPointData = this.data.endPoints;
		
		//if (exerciseSettings.shuffleEndPoints){
			endPointData = shuffleArray(endPointData);
		//}
		
		var yPos = 0;
		
		this.endPoints = new Array();
		
		for (var i = 0; i < endPointData.length; i++){
			startPointData[i].type = 'endPoint';
			this.endPoints[i] = new Kinetic.ConnectPoint({
				'data': endPointData[i],
				'y': yPos
			});
			this.endPointsGroup.add(this.endPoints[i]);
			
			yPos += this.endPoints[i].getHeight() + 25;
		}
	},
	
	eventHandlers: function(){
		var thisObject = this;
		
		for (var i = 0; i < this.startPoints.length; i++){
			this.startPoints[i].hitzone1.on('dragstart', function(evt){
				this.getParent().activeHitzone = 1;
				
				thisObject.dragStart(this, evt);
				
				this.getParent().resetInactiveHitzone();
			});
			this.startPoints[i].hitzone2.on('dragstart', function(evt){
				this.getParent().activeHitzone = 2;
				
				thisObject.dragStart(this, evt);
				
				this.getParent().resetInactiveHitzone();
			});
			
			
			this.startPoints[i].hitzone1.on('dragmove', function(evt){
				thisObject.dragMove(this, evt);
			});
			this.startPoints[i].hitzone2.on('dragmove', function(evt){
				thisObject.dragMove(this, evt);
			});
			
			
			this.startPoints[i].hitzone1.on('dragend', function(evt){
				thisObject.dragEnd(this, evt);
			});
			this.startPoints[i].hitzone2.on('dragend', function(evt){
				thisObject.dragEnd(this, evt);
			});
		}
	},
	
	dragStart: function(thisObject, evt){
		var parent = thisObject.getParent();
		
		parent.dragCircleStart.setOpacity(1);
		parent.dragCircleEnd.setOpacity(1);
		parent.dragLine.setOpacity(1);
	},
	
	dragMove: function(thisObject, evt){
		var parent = thisObject.getParent();
		var mousePosition = getMousePosition('#exerciseCanvas', evt);
		
		var containerX = parent.getLayer().getX();
		var containerY = parent.getLayer().getY();
		
		var elementX = parent.getX();
		var elementY = parent.getY();
		
		var destX = mousePosition.x - containerX - elementX;
		var destY = mousePosition.y - containerY - elementY;
		
		parent.dragCircleEnd.setX(destX);
		parent.dragCircleEnd.setY(destY);
		
		parent.dragLine.setPoints([parent.dragCircleStart.getX(), parent.dragCircleStart.getY(), destX, destY]);
		
		parent.getLayer().draw();
	},
	
	dragEnd: function(thisObject, evt){
		var parent = thisObject.getParent();
		
		// check position
		var mousePosition = getMousePosition('#exerciseCanvas', evt);
		
		var endPoints = this.endPoints;
		
		var hitCheck = false;
		var centerX = 0;
		var centerY = 0;
		
		for (var j = 0; j < endPoints.length; j++){
			var endHZ = endPoints[j].getAbsoluteHitzonePosition();
			endHZX2 = endHZ.x + 36;
			endHZY2 = endHZ.y + 36;
			
			if (
				(mousePosition.x >= endHZ.x && mousePosition.x <= endHZX2)
				&&
				(mousePosition.y >= endHZ.y && mousePosition.y <= endHZY2)
			){
				hitCheck = true;
				
				// return previous connection to this endPoint, if there is one
				this.returnPreviousConnection(endPoints[j].data.id);
				
				// snap to endPoint
				centerX = endHZ.x + ((endHZX2 - endHZ.x) / 2) - parent.getAbsolutePosition().x;
				centerY = endHZ.y + ((endHZY2 - endHZ.y) / 2) - parent.getAbsolutePosition().y;
				
				// set connected
				parent.connected = endPoints[j].data.id;
			}
		}
		
			
		if (!hitCheck){
			// return
			var startPosition = parent.getStartPosition();
			
			centerX = startPosition.x;
			centerY = startPosition.y;
		}
			
		parent.snapToPosition(centerX, centerY);
	},
	
	returnPreviousConnection: function(endPointId){
		var startPosition = null;
		for (var i = 0; i < this.startPoints.length; i++){
			if (this.startPoints[i].connected == endPointId){
				startPosition = this.startPoints[i].getStartPosition();
				this.startPoints[i].snapToPosition(startPosition.x, startPosition.y);
				
				this.startPoints[i].connected = null;
			}
		}
	},
	
	checkAnswer: function(){
		this.attempts -= 1;
		
		if (this.attempts == 0){
			this.blockExercise();
		}
		
		this.correct = true;
		
		for (var i = 0; i < this.startPoints.length; i++){
			if (this.startPoints[i].data.connectTo == this.startPoints[i].connected){
				// mark correct
				if (eqSettings.mode == 'exercise'){
					this.startPoints[i].setCorrect();
				}
			} else if (this.startPoints[i].connected == undefined){
				// mark forgot
				if (eqSettings.mode == 'exercise'){
					this.startPoints[i].setForgot();
				}
				this.correct = false;
			} else {
				// mark wrong
				if (eqSettings.mode == 'exercise'){
					this.startPoints[i].setWrong();
				}
				this.correct = false;
			}
		}
		
		this.getLayer().draw();
		
		this.showFeedback(this.correct, this.attempts);
	}
}

Kinetic.Util.extend(Kinetic.Connect, Kinetic.ExerciseType);