extends Player
class_name WolfPlayer

var role: Role:
	set(val):
		role = val.duplicate(true)
		role_changed.emit(role)
		if is_multiplayer_authority():
			sync_role.rpc(role.name if role != null else "")
var team: Team: 
	set(val):
		team = val
		team_changed.emit(team)
		if is_multiplayer_authority():
			sync_team.rpc(team.name if team != null else "")
var alive: bool = true:
	set(val):
		alive = val
		alive_changed.emit(alive)

var vote: String = ""

var night_action_chosen: NightAction = null
var night_action_answer: String = ""

var visit_callbacks: Array[Callable] = []
var leave_callbacks: Array[Callable] = []
var murder_callbacks: Array[Callable] = []
var execute_callbacks: Array[Callable] = []

signal murdered(killer: WolfPlayer)
signal executed(hammer: WolfPlayer)
signal died()
signal team_changed(team: Team)
signal role_changed(role: Role)
signal alive_changed(alive: bool)

enum CallbackFlags { KEEP_CALLBACK = 1, STOP_PROCESS = 2 }

@rpc("authority", "call_remote", "reliable")
func sync_team(team_name: String) -> void:
	team = Team.teams.get(team_name)

@rpc("authority", "call_remote", "reliable")
func sync_role(role_name: String) -> void:
	role = Role.roles.get(role_name)
	
@rpc("any_peer","call_remote", "reliable")
func use_night_action(night_action_name: String) -> void:
	var night_action: NightAction = get_night_actions().get(night_action_name,null)
	if night_action != null:
		night_action.setup(self)
		night_action_chosen = night_action

func get_night_actions() -> Dictionary: #[String, NightAction]:
	var actions: Dictionary = {}
	#var actions: Dictionary[String, NightAction] = {}
	if team != null and team.night_action != null:
		actions[team.name] = team.night_action
	if role != null and role.night_action != null:
		actions[role.name] = role.night_action
		
	#for key in actions.keys():
		#var night_action: NightAction = actions[key]
		#if night_action.team_nightly_action and 
	return actions
	
func game_reset() -> void:
	alive = true
	visit_callbacks.clear()
	murder_callbacks.clear()
	execute_callbacks.clear()
	leave_callbacks.clear()
	day_reset()
	night_reset()
	#team = null
	#role = null
	
func day_reset() -> void:
	vote = ""
	
func night_reset() -> void:
	visit_callbacks.clear()
	murder_callbacks.clear()
	execute_callbacks.clear()
	leave_callbacks.clear()
	night_action_chosen = null
	night_action_answer = ""
	
func leave() -> bool:
	return notify_callback_list(leave_callbacks, "")
	
func visit(visitor: WolfPlayer) -> bool:
	return notify_callback_list(visit_callbacks, visitor)
	
func execute(hammer: WolfPlayer) -> bool:
	if !alive:
		return false
	
	var unprotected: bool = notify_callback_list(execute_callbacks, hammer)
	
	if unprotected:
		alive = false
		print("%s has been executed!" % [player_name])
		executed.emit(hammer)
	return !alive
	
func murder(killer: WolfPlayer) -> bool:
	if !alive:
		return false
		
	var unprotected: bool = notify_callback_list(murder_callbacks, killer)
	
	if unprotected:
		alive = false
		print("%s has been murdered by %s!" % [player_name, killer.player_name])
		murdered.emit(killer)
	return true # you succeeded in ATTEMPTING to kill them
	
func add_murder_callback(callback: Callable):
	murder_callbacks.append(callback)
	
func add_visit_callback(callback: Callable):
	if callback == null:
		print("wtf?????")
	visit_callbacks.append(callback)
	
func notify_callback_list(callbacks: Array[Callable], data: Variant) -> bool:
	var finished: bool = true
	var expired_callbacks: Array[Callable] = []
	for callback in callbacks:
		var flags: int = callback.call(self, data)
		if !(flags & CallbackFlags.KEEP_CALLBACK):
			expired_callbacks.append(callback)
		if flags & CallbackFlags.STOP_PROCESS:
			finished = false
			break
	for callback in expired_callbacks:
		murder_callbacks.erase(callback)
	return finished
	
#func save_from_death() -> bool:
	#if !saved_from_death:
		#saved_from_death = true
		#return true
	#return false