extends Node
@onready var chara = get_parent()
@onready var flipped = chara.flipped
var positionGoalX : float = 0.0
var positionGoalVelocityX : float = 0.0
var positionGoalXFrames : int = 0
var accelX : float = 0.0
var accelY : float = 0.0
var accelXGoal : float
var accelYGoal : float
var velControlX : float = 0.0
var velControlY : float = 0.0
var accelControlX : float
var accelControlY : float
var accelAnimX := 0.0
var accelAnimXGoal := 0.0
var accelAnimY := 0.0
var accelAnimYGoal := 0.0
var knockbackTakenX := 0.0 #applies for each frame until knockbackAccelX can lessen this number enough
var knockbackAccelX := 0.0 #accel to get rid of knockback
var knockbackTakenY := 0.0 #same as above
var knockbackAccelY := 0.0 #same as above

var overrideAccelX := 0.0
var overrideAccelXGoal := 0.0
var override := false

var enemyMovementHandler

var locked := false
var lockedVelocity := Vector2(0,0)


@export var desiredVelocity := Vector4(0.0,0.0,0.0,0.0)

#func _ready() -> void:
#	await chara.get_node("LastToLoad").ready
#	enemyMovementHandler = chara.enemy.get_node("MovementHandler")

func resetValues():
	accelX = 0.0
	accelY = 0.0
	accelXGoal = 0.0
	accelYGoal = 0.0
	velControlX = 0.0
	velControlY = 0.0
	accelControlX = 0.0
	accelControlY = 0.0
	accelAnimX = 0.0
	accelAnimXGoal = 0.0
	accelAnimY = 0.0
	accelAnimYGoal = 0.0
	knockbackTakenX = 0.0
	knockbackAccelX = 0.0
	knockbackTakenY = 0.0
	knockbackAccelY = 0.0
	positionGoalX = 0.0
	positionGoalXFrames = 0
	positionGoalVelocityX = 0.0

func lock():
	locked = true
	lockedVelocity = chara.velocity
	chara.velocity = Vector2(0,0)

func unlock():
	locked = false
	chara.velocity = lockedVelocity
	print(lockedVelocity)
	print(chara.velocity)

func addVelX(vel : float):
	chara.velocity.x += vel * flipped
	
func addVelY(vel : float):
	chara.velocity.y += vel

func addVelVec(vel : Vector2):
	chara.velocity += Vector2(vel.x * flipped, vel.y)
	
func setVel(vel : Vector2):
	chara.velocity = Vector2(vel.x * flipped, vel.y)
	
func setControlVel(vel : Vector2,accel : Vector2): #TODO have this change with knockback and stuff
	velControlX = vel.x
	velControlY = vel.y
	accelControlX = accel.x
	accelControlY = accel.y
	
	
func setAnimVel(vel : Vector2): #TODO have this change with knockback and stuff
	chara.velocity = Vector2(vel.x * flipped, vel.y)

func setAccel(accX : float, accY : float, accXGoal : float, accYGoal : float):
	accelX = accX
	accelXGoal = accXGoal * flipped
	accelY = accY
	accelYGoal = accYGoal * flipped
func setAccelX(accel : float, accelGoal : float):
	accelX = accel
	accelXGoal = accelGoal * flipped
	
func setAnAcX(accel : float, accelGoal : float): #setAnimationAccelX()
	accelAnimX = accel
	accelAnimXGoal = accelGoal * flipped
	
func addAnVelX(vel : float,accel : float, accelGoal : float): #addAnimationVelocityX
	chara.velocity.x += vel * flipped
	accelAnimX = accel
	accelAnimXGoal = accelGoal * flipped
	
func addAnVelY(vel : float,accel : float, accelGoal : float): #addAnimationVelocityY
	chara.velocity.y += vel * -1
	accelAnimY = accel
	accelAnimYGoal = accelGoal * -1

func _physics_process(delta: float) -> void:
	if enemyMovementHandler == null and chara.enemy != null:
		enemyMovementHandler = chara.enemy.get_node("MovementHandler")
	
	if override or locked:
		return
		
	flipped = chara.flipped
	"""
	if positionGoalX != 0.0: #TODO THIS IS SO BROKEN, workaround

		#if positionGoalX > chara.position.x:
		#	chara.velocity.x = positionGoalVelocityX / delta
		#else:
		#	chara.velocity.x = -positionGoalVelocityX / delta
		#chara.position.x = move_toward(chara.position.x,positionGoalX, 1000 * .0167)
		#
		chara.position.x = move_toward(chara.position.x,positionGoalX, 3000 * delta)
		if snapped(chara.position.x,1) == snapped(positionGoalX, 1): 
			positionGoalX = 0.0
			positionGoalXFrames = 0
			positionGoalVelocityX = 0.0
			chara.velocity.x = 0
		return
	"""
	if accelControlX != 0.0 and chara.velocity.x != velControlX: #TODO have this change with knockback and stuff
		chara.velocity.x = move_toward(chara.velocity.x, velControlX, accelControlX)
	if accelControlY != 0.0 and chara.velocity.y != velControlY: #TODO have this change with knockback and stuff
		chara.velocity.y = move_toward(chara.velocity.y, velControlY, accelControlY)
		
	if accelX != 0.0:
		chara.velocity.x = move_toward(chara.velocity.x, accelXGoal, accelX)
		if chara.velocity.x == accelXGoal:
			accelX = 0.0
	if accelY != 0.0:
		chara.velocity.y = move_toward(chara.velocity.y, accelYGoal, accelY)
		if chara.velocity.y == accelYGoal:
			accelY = 0.0
	if accelAnimX != 0.0:
		chara.velocity.x = move_toward(chara.velocity.x, accelAnimXGoal, accelAnimX)
		if chara.velocity.x == accelAnimXGoal:
			accelAnimX = 0.0
	if accelAnimY != 0.0:
		chara.velocity.y = move_toward(chara.velocity.y, accelAnimYGoal, accelAnimY)
		if chara.velocity.y == accelAnimYGoal:
			accelAnimY = 0.0
	if knockbackTakenX != 0.0:
		chara.velocity.x += knockbackTakenX * -flipped
		knockbackTakenX = move_toward(knockbackTakenX, 0.0, knockbackAccelX)
	if knockbackTakenY != 0.0:
		chara.velocity.y += knockbackTakenY
		knockbackTakenY = move_toward(knockbackTakenY, 0.0, knockbackAccelY)
	
	if desiredVelocity != Vector4(0.0,0.0,0.0,0.0):
		if not inKnockback():
			chara.velocity.x = move_toward(chara.velocity.x,desiredVelocity.x, desiredVelocity.z)
			chara.velocity.y = move_toward(chara.velocity.y,desiredVelocity.y, desiredVelocity.w)
		else:
			chara.velocity.x = move_toward(chara.velocity.x,desiredVelocity.x, desiredVelocity.z/4.0)
			chara.velocity.y = move_toward(chara.velocity.y,desiredVelocity.y, desiredVelocity.w/4.0)
	
	if overrideAccelX != 0.0:
		chara.velocity.x = move_toward(chara.velocity.x, overrideAccelXGoal, overrideAccelX)
		if chara.velocity.x == overrideAccelXGoal:
			overrideAccelX = 0.0

func inKnockback():
	if knockbackTakenX != 0.0 or knockbackTakenY != 0.0:
		return true
	return false

func setKnkBk(val : Vector2, valAccel : Vector2):
	knockbackTakenX = val.x
	knockbackAccelX = valAccel.x
	knockbackTakenY = val.y
	knockbackAccelY = valAccel.y

func setEnemyKnkBk(val : Vector2, valAccel : Vector2):
	enemyMovementHandler.knockbackTakenX = val.x
	enemyMovementHandler.knockbackAccelX = valAccel.x
	enemyMovementHandler.knockbackTakenY = val.y
	enemyMovementHandler.knockbackAccelY = valAccel.y
	
func setEnemyKnkBkX(valX : float, valAccelX : float):
	enemyMovementHandler.knockbackTakenX = valX
	enemyMovementHandler.knockbackAccelX = valAccelX
	
func reset():
	chara.velocity = Vector2(0,0)
	resetValues()

func overrideX(vel : float, accel : float, accelGoal : float):
	resetValues()
	chara.velocity.x += vel * flipped
	overrideAccelX = accel
	overrideAccelXGoal = accelGoal * flipped

func overrideChanges(duration : int):
	override = true
	get_tree().create_timer(duration * .0167).timeout
	override = false

func disableGravity():
	chara.gravityOn = 0
func enableGravity():
	chara.gravityOn = 1

func accelToEnemyPosX(addPosition : float, frames : int):
	chara.velocity.x = 0
	chara.position.x = chara.enemy.position.x - (addPosition * flipped)
	#positionGoalX = chara.enemy.position.x - (addPosition * flipped)
	#positionGoalXFrames = frames
	#positionGoalVelocityX = abs(abs(positionGoalX) - abs(chara.position.x)) / (positionGoalXFrames) #TODO this position may get messed up when chara is on the wrong side

func teleportToEnemyPosX(addPosition : float):
	chara.velocity.x = 0
	chara.position.x = chara.enemy.position.x - (addPosition * flipped)