extends Node2D

const DragPoly2DScene = preload("res://DragPoly2D.tscn")
# export(NodePath) onready var dottedLineNode = get_node(dottedLineNode) as Node
export(PackedScene) var dottedLineScene
var dottedLineSceneInstance
var doOnce = false
var leftMouseDragging = false
var startDragPos = Vector2()
var startScreenPos = Vector2()
var dragRatio = 1
var startDragNode
var endDragNode
var polyWidth = 10.0
var polyPoints = [PoolVector2Array()]
var centerPolyPt = Vector2()
var dragPolyInstance : DragPoly2D
var dragPolySceneArray = [DragPoly2D]
var dragPolyCounter = 0



# Declare member variables here. Examples:
# var a = 2
# var b = "text"


# Called when the node enters the scene tree for the first time.
func _ready():
	set_process_input(true)
	
	pass # Replace with function body.
	dottedLineSceneInstance = dottedLineScene.instance()
	startDragNode = $StartPos
	endDragNode = $EndPos

func _draw():
	#var points = PoolVector2Array()
	var colour = PoolColorArray()
	colour = [Color(0.5,0.5,0.5,1.0)]
	if polyPoints.size() > 0:
		draw_polygon(polyPoints,colour)
		print("drawing!")
	# colour = [Color(slider.value,1,1,1)]
	

func _process(_delta):
	pass
	# if !doOnce:
	# 	print(dottedLineSceneInstance.SayHi())
	# 	doOnce = true
	
func _input(event):
	if event.is_action("Click"):
		if event.is_pressed():
			startDragPos = event.position
			startDragNode.position = startDragPos
			startScreenPos = position
			leftMouseDragging = true
			dottedLineSceneInstance.SetFrom(startDragNode.position)

		else:
			# create a new instance of dragPoly2D
			# append it to the dragPolySceneArray
			# modify the dragPolySceneArray[dragPolyCounter].shape
			
			dragPolySceneArray.append(CreateDragPolyInstanceAndAddAsChild())
			
			dragPolySceneArray[dragPolyCounter].set_shape(polyPoints)
			print(str(dragPolySceneArray[dragPolyCounter].get_collision_layer()))
			update()
			leftMouseDragging = false
			startDragPos = Vector2()
			startScreenPos = Vector2()
			centerPolyPt = Vector2()
			polyPoints = [PoolVector2Array()]
		#dottedLineSceneInstance.SetFrom(Vector2())
		#dottedLineSceneInstance.SetTo(Vector2())
# mouse release click...
	elif event.is_action("AltClick"):
		if event.is_pressed():
			#spawn rock at mouse position
			var rock = $TestBoulder.duplicate()
			add_child(rock)
			rock.set_global_position(event.position)
			print(str(rock.get_collision_mask()))
		
# dragging with mouse...
	elif event is InputEventMouseMotion and leftMouseDragging:
		var dragVector = Vector2()
		var perpLeftVector = Vector2()
		var perpRightVector = Vector2()
		var startPolyPArray = []
		var endPolyPArray = []
		var combinedPolyPArray = []
		
		endDragNode.position = event.position
		dragVector = GetDragVector(startDragNode.position, endDragNode.position)
		perpLeftVector = GetCCWPerpendicularVector(dragVector)
		perpRightVector = GetCWPerpendicularVector(dragVector)
		#dottedLineSceneInstance.SetTo(endDragNode.position)
		startPolyPArray = CalcStartingPolyPoints(perpLeftVector,perpRightVector, startDragNode.position) 
		endPolyPArray = CalcEndPolyPoints(perpLeftVector,perpRightVector,endDragNode.position)
		combinedPolyPArray = startPolyPArray + endPolyPArray
		# var unsortedArray = combinedPolyPArray
		# for p in unsortedArray.size():
		# 	print("unsorted array + " + str(unsortedArray[p]))
		
		
		centerPolyPt = CalcCenterPoint((combinedPolyPArray))
		combinedPolyPArray.sort_custom(self, "SortPointsCCW")
		# for p in combinedPolyPArray.size():
		# 	print("sorted array + " + str(combinedPolyPArray[p]))
		polyPoints = combinedPolyPArray
		#_draw()
		update()
		# print(str(CalcCenterPoint(polyArray)))
		# for p in polyArray.size():
		# 	print("whole array " + str(polyArray[p]))
		#dottedLineSceneInstance.DoDashedLineUpdate()

		# this is for camera position
		# position = GetPosition(event)
		pass

func CreateDragPolyInstanceAndAddAsChild():
	var m_dragPolyInstance = DragPoly2DScene.instance()
	add_child(m_dragPolyInstance)
	dragPolyCounter += 1
	return m_dragPolyInstance

func GetPosition(eventVar) -> Vector2:
	# return zoom * ((mouseStartPos - eventVar.position) * dragRatio) + screenStartPosition
	return (startDragPos - eventVar.position) * dragRatio + startScreenPos

func GetDragVector(startPos, endPos) -> Vector2:
	return endPos - startPos

func GetCWPerpendicularVector(vectorFromDrag) -> Vector2:
	var v = vectorFromDrag
	# rotate right (clockwise)
	return Vector2(-v.y, v.x).normalized()

func GetCCWPerpendicularVector(vectorFromDrag) -> Vector2:
	var v = vectorFromDrag
	# rotate left (counter-clockwise)
	return Vector2(v.y, -v.x).normalized()

func CalcStartingPolyPoints(leftVec,rightVec, startPos) -> PoolVector2Array:
	var startPolyPArray = []
	var p1 = startPos + (leftVec * polyWidth)
	var p2 = startPos + (rightVec * polyWidth)
	startPolyPArray.push_back(p1)
	startPolyPArray.push_back(p2)
	
	# for p in startPolyPArray.size():
	# 	print(str(startPolyPArray[p]))
	return startPolyPArray

func CalcEndPolyPoints(leftVec,rightVec,endPos) -> PoolVector2Array:
	var endPolyPArray = []
	var p1 = endPos + (leftVec * polyWidth)
	var p2 = endPos + (rightVec * polyWidth)
	endPolyPArray.push_back(p1)
	endPolyPArray.push_back(p2)

	# for p in endPolyPArray.size():
	# 	print("end points " + str(endPolyPArray[p]))
	return endPolyPArray

func CalcCenterPoint(pointArray) -> Vector2:
	var totalX = 0
	var totalY = 0

	for p in pointArray.size():
		totalX += pointArray[p].x
		totalY += pointArray[p].y

	var centerX = totalX / pointArray.size()
	var centerY = totalY / pointArray.size()
	return Vector2(centerX, centerY)

func SortPointsCCW(a, b):
	return (a - centerPolyPt).angle() > (b - centerPolyPt).angle()