extends Node

const GUIDESet = preload("guide_set.gd")
const GUIDEReset = preload("guide_reset.gd")
const GUIDEInputTracker = preload("guide_input_tracker.gd")

## This is emitted whenever input mappings change (either due to mapping
## contexts being enabled/disabled or remapping configs being re-applied or
## joystick devices being connected/disconnected).
## This is useful for updating UI prompts.
signal input_mappings_changed()

## The currently active contexts. Key is the context, value is the priority
var _active_contexts:Dictionary = {}
## The currently active action mappings.
var _active_action_mappings:Array[GUIDEActionMapping] = []

## The currently active remapping config.
var _active_remapping_config:GUIDERemappingConfig

## All currently active inputs as collected from the active input mappings
var _active_inputs:Array[GUIDEInput] = []

## A dictionary of actions sharing input. Key is the action, value
## is an array of lower-priority actions that share input with the 
## key action.
var _actions_sharing_input:Dictionary = {}

## A reference to the reset node which resets inputs that need a reset per frame
## This is an extra node because the reset should run at the end of the frame
## before new input is processed at the beginning of the frame.
var _reset_node:GUIDEReset

## The current input state. This is used to track the state of the inputs
## and serves as a basis for the GUIDEInputs.
var _input_state:GUIDEInputState


func _ready():
	process_mode = Node.PROCESS_MODE_ALWAYS
	_reset_node = GUIDEReset.new()
	_input_state = GUIDEInputState.new()
	add_child(_reset_node)
	# attach to the current viewport to get input events
	GUIDEInputTracker._instrument.call_deferred(get_viewport())
	
	get_tree().node_added.connect(_on_node_added)
	
	# Emit a change of input mappings whenever a joystick was connected
	# or disconnected.
	Input.joy_connection_changed.connect(func(ig, ig2): input_mappings_changed.emit())


## Called when a node is added to the tree. If the node is a window
## GUIDE will instrument it to get events when the window is focused.	
func _on_node_added(node:Node) -> void:
	if not node is Window:
		return
		
	GUIDEInputTracker._instrument(node)
	

## Injects input into GUIDE. GUIDE will call this automatically but 
## can also be used to manually inject input for GUIDE to handle 
func inject_input(event:InputEvent) -> void:
	if event is InputEventAction:
		return  # we don't react to Godot's built-in events

	# The input state is the sole consumer of input events. It will notify
	# GUIDEInputs when relevant input events happen. This way we don't need
	# to process input events multiple times and at the same time always have
	# the full picture of the input state.
	_input_state._input(event)


## Applies an input remapping config. This will override all input bindings in the 
## currently loaded mapping contexts with the bindings from the configuration.	
## Note that GUIDE will not track changes to the remapping config. If your remapping
## config changes, you will need to call this method again.
func set_remapping_config(config:GUIDERemappingConfig) -> void:
	_active_remapping_config = config
	_update_caches()
	
	
## Enables the given context with the given priority. Lower numbers have higher priority. If 
## disable_others is set to true, all other currently enabled mapping contexts will be disabled.
func enable_mapping_context(context:GUIDEMappingContext, disable_others:bool = false,  priority:int = 0):
	if not is_instance_valid(context):
		push_error("Null context given. Ignoring.")
		return
	
	if disable_others:
		_active_contexts.clear()	
	
	_active_contexts[context] = priority
	_update_caches()
	
	
## Disables the given mapping context.
func disable_mapping_context(context:GUIDEMappingContext):
	if not is_instance_valid(context):
		push_error("Null context given. Ignoring.")
		return

	_active_contexts.erase(context)
	_update_caches()


## Checks whether the given mapping context is currently enabled.
func is_mapping_context_enabled(context:GUIDEMappingContext) -> bool:
	return _active_contexts.has(context)


## Returns the currently enabled mapping contexts
func get_enabled_mapping_contexts() -> Array[GUIDEMappingContext]:
	var result:Array[GUIDEMappingContext] = []
	for key in _active_contexts.keys():
		result.append(key)
	return result


## Processes all currently active actions
func _process(delta:float) -> void:
	var blocked_actions:GUIDESet = GUIDESet.new()
	
	for action_mapping:GUIDEActionMapping in _active_action_mappings:
		
		var action:GUIDEAction = action_mapping.action
				
		# Walk over all input mappings for this action and consolidate state
		# and result value.
		var consolidated_value:Vector3 = Vector3.ZERO
		var consolidated_trigger_state:GUIDETrigger.GUIDETriggerState
		
		for input_mapping:GUIDEInputMapping in action_mapping.input_mappings:
			input_mapping._update_state(delta, action.action_value_type)
			consolidated_value += input_mapping._value
			consolidated_trigger_state = max(consolidated_trigger_state, input_mapping._state)
		
		# we do the blocking check only here because triggers may need to run anyways
		# (e.g. to collect hold times).
		if blocked_actions.has(action):
			consolidated_trigger_state = GUIDETrigger.GUIDETriggerState.NONE
		
		if action.block_lower_priority_actions and \
			consolidated_trigger_state == GUIDETrigger.GUIDETriggerState.TRIGGERED and \
			_actions_sharing_input.has(action):
			for blocked_action in _actions_sharing_input[action]:
				blocked_actions.add(blocked_action)
			
		
		# Now state change events.
		match(action._last_state):
			GUIDEAction.GUIDEActionState.TRIGGERED:
				match(consolidated_trigger_state):
					GUIDETrigger.GUIDETriggerState.NONE:
						action._completed(consolidated_value)
					GUIDETrigger.GUIDETriggerState.ONGOING:
						action._ongoing(consolidated_value, delta)
					GUIDETrigger.GUIDETriggerState.TRIGGERED:
						action._triggered(consolidated_value, delta)
						
			GUIDEAction.GUIDEActionState.ONGOING:
				match(consolidated_trigger_state):
					GUIDETrigger.GUIDETriggerState.NONE:
						action._cancelled(consolidated_value)
					GUIDETrigger.GUIDETriggerState.ONGOING:
						action._ongoing(consolidated_value, delta)
					GUIDETrigger.GUIDETriggerState.TRIGGERED:
						action._triggered(consolidated_value, delta)
						
			GUIDEAction.GUIDEActionState.COMPLETED:
				match(consolidated_trigger_state):
					GUIDETrigger.GUIDETriggerState.NONE:
						# make sure the value updated but don't emit any other events
						action._update_value(consolidated_value)
					GUIDETrigger.GUIDETriggerState.ONGOING:
						action._started(consolidated_value)
					GUIDETrigger.GUIDETriggerState.TRIGGERED:
						action._triggered(consolidated_value, delta)
						
func _update_caches():
	# Notify existing inputs that they aren no longer required
	for input:GUIDEInput in _active_inputs:
		input._reset()
		input._end_usage()
		
	# Cancel all actions, so they don't remain in weird states.
	for mapping:GUIDEActionMapping in _active_action_mappings:
		match mapping.action._last_state:
			GUIDEAction.GUIDEActionState.ONGOING:
				mapping.action._cancelled(Vector3.ZERO)
			GUIDEAction.GUIDEActionState.TRIGGERED:
				mapping.action._completed(Vector3.ZERO)
		# notify all modifiers they are no longer in use
		for input_mapping in mapping.input_mappings:
			for modifier in input_mapping.modifiers:
				modifier._end_usage()
		
	_active_inputs.clear()
	_active_action_mappings.clear()
	_actions_sharing_input.clear()
	
	var sorted_contexts:Array[Dictionary] = []
	
	for context:GUIDEMappingContext in _active_contexts.keys():
		sorted_contexts.append({"context": context, "priority": _active_contexts[context]})

	sorted_contexts.sort_custom( func(a,b): return a.priority < b.priority )
	
	# The actions we already have processed. Same action may appear in different
	# contexts, so if we find the same action twice, only the first instance wins.
	var processed_actions:GUIDESet = GUIDESet.new()
	var consolidated_inputs:GUIDESet = GUIDESet.new()

	for entry:Dictionary in sorted_contexts:
		var context:GUIDEMappingContext = entry.context
		var position:int = 0
		for action_mapping:GUIDEActionMapping in context.mappings:
			position += 1
			var action := action_mapping.action
			
			# Mapping may be misconfigured, so we need to handle the case
			# that the action is missing.
			if action == null:
				push_warning("Mapping at position %s in context %s has no action set. This mapping will be ignored." % [position, context.resource_path])
				continue
			
			# If the action was already configured in a higher priority context,
			# we'll skip it.
			if processed_actions.has(action):
				# skip
				continue
				
			processed_actions.add(action)
			
			# We consolidate the inputs here, so we'll internally build a new
			# action mapping that uses consolidated inputs rather than the
			# original ones. This achieves multiple things:
			# - if two actions check for the same input, we only need to
			#   process the input once instead of twice.
			# - it allows us to prioritize input, if two actions check for  
			#   the same input. This way the first action can consume the
			#   input and not have it affect further actions.
			# - we make sure nobody shares triggers as they are stateful and
			#   should not be shared.
			
			var effective_mapping  = GUIDEActionMapping.new()
			effective_mapping.action = action

			# now update the input mappings
			for index in action_mapping.input_mappings.size():
				var bound_input:GUIDEInput = action_mapping.input_mappings[index].input
				
				# if the mapping has an override for the input, apply it.
				if _active_remapping_config != null and \
						_active_remapping_config._has(context, action, index):
					bound_input = _active_remapping_config._get_bound_input_or_null(context, action, index)

				# make a new input mapping
				var new_input_mapping := GUIDEInputMapping.new()

				# can be null for combo mappings, so check that
				if bound_input != null:
					# check if we already have this kind of input
					var existing = consolidated_inputs.first_match(func(it:GUIDEInput): return it.is_same_as(bound_input))
					if existing != null:
						# if we have this already, use the instance we have
						bound_input = existing
					else:
						# otherwise register this input into the consolidated input
						consolidated_inputs.add(bound_input)
					
				new_input_mapping.input = bound_input
				# modifiers cannot be re-bound so we can just use the one
				# from the original configuration. this is also needed for shared
				# modifiers to work.
				new_input_mapping.modifiers = action_mapping.input_mappings[index].modifiers
				# triggers also cannot be re-bound but we still make a copy 
				# to ensure that no shared triggers exist.
				new_input_mapping.triggers = []
				
				for trigger in action_mapping.input_mappings[index].triggers:
					new_input_mapping.triggers.append(trigger.duplicate())
				
				new_input_mapping._initialize()
				
				# and add it to the new mapping
				effective_mapping.input_mappings.append(new_input_mapping)

				
			# if any binding remains, add the mapping to the list of active
			# action mappings
			if not effective_mapping.input_mappings.is_empty():
				_active_action_mappings.append(effective_mapping)

	# INVARIANT: all _active_action_mappings now have actions.

	# now we have a new set of active inputs		
	for input:GUIDEInput in consolidated_inputs.values():
		_active_inputs.append(input)
		
	# prepare the action input share lookup table
	for i:int in _active_action_mappings.size():
		
		var mapping = _active_action_mappings[i]
		
		if mapping.action.block_lower_priority_actions:
			# first find out if the action uses any chorded actions and 
			# collect all inputs that this action uses
			var chorded_actions:GUIDESet = GUIDESet.new()
			var inputs:GUIDESet = GUIDESet.new()
			var blocked_actions:GUIDESet = GUIDESet.new()
			for input_mapping:GUIDEInputMapping in mapping.input_mappings:
				if input_mapping.input != null:
					inputs.add(input_mapping.input)		
						
				for trigger:GUIDETrigger in input_mapping.triggers:
					if trigger is GUIDETriggerChordedAction and trigger.action != null:
						chorded_actions.add(trigger.action)
						
			# Now the action that has a chorded action (A) needs to make sure that
			# the chorded action it depends upon (B) is not blocked (otherwise A would 
			# never trigger) and if that chorded action (B) in turn depends on chorded actions. So 
			# if chorded actions build a chain, we need to keep the full
			# chain unblocked. In addition we need to add the inputs of all
			# these chorded actions to the list of blocked inputs.
			for j:int in range(i+1, _active_action_mappings.size()):
				var inner_mapping = _active_action_mappings[j]
				# this is a chorded action that is used by one other action
				# in the chain.
				if chorded_actions.has(inner_mapping.action):
					for input_mapping:GUIDEInputMapping in inner_mapping.input_mappings:
						# put all of its inputs into the list of blocked inputs
						if input_mapping.input != null:
							inputs.add(input_mapping.input)
			
						# also if this mapping in turn again depends on a chorded
						# action, ad this one to the list of chorded actions
						for trigger:GUIDETrigger in input_mapping.triggers:
							if trigger is GUIDETriggerChordedAction and trigger.action != null:
								chorded_actions.add(trigger.action)
			
			# now find lower priority actions that share input
			for j:int in range(i+1, _active_action_mappings.size()):
				var inner_mapping = _active_action_mappings[j]
				if chorded_actions.has(inner_mapping.action):
					continue
					
				for input_mapping:GUIDEInputMapping in inner_mapping.input_mappings:
					if input_mapping.input == null:
						continue
					
					# because we consolidated input, we can now do an == comparison
					# to find equal input.
					if inputs.has(input_mapping.input):
						blocked_actions.add(inner_mapping.action)
						# we can continue to the next action
						break 
										
			if not blocked_actions.is_empty():
				_actions_sharing_input[mapping.action] = blocked_actions.values()
				
	_reset_node._inputs_to_reset.clear()
	for input:GUIDEInput in _active_inputs:
		# finally collect which inputs we need to reset per frame
		if input._needs_reset():
			_reset_node._inputs_to_reset.append(input)

		# Give the state to the input
		input._state = _input_state		
		# Notify inputs that GUIDE is about to use them
		input._begin_usage()
	
	for mapping in _active_action_mappings:
		for input_mapping in mapping.input_mappings:
			# notify modifiers they will be used.
			for modifier in input_mapping.modifiers:
				modifier._begin_usage()
		
			# and copy over the hold time threshold from the mapping
			mapping.action._trigger_hold_threshold = input_mapping._trigger_hold_threshold
		
	# and notify interested parties that the input mappings have changed
	input_mappings_changed.emit()