class_name StatResolver
extends RefCounted

const JudgementPolicyResource := preload("res://resources/judgement_policy.tres")


static func resolve_damage(base_attack: float, action: Resource, judgement: Variant = {}, buffs: Variant = null, burst: Variant = null) -> float:
	var judgement_dict := _as_dict(judgement)
	var action_mult := _resource_float(action, "damage_mult", 1.0)
	var judgement_mult := _judgement_channel_mult(judgement_dict, &"damage", "damage_mult", 1.0)
	var buff_mult := _provider_mult(buffs, "damage_mult", action)
	var burst_mult := _provider_mult(burst, "damage_mult", action)
	return base_attack * action_mult * judgement_mult * buff_mult * burst_mult


static func resolve_cost(action: Resource, judgement: Variant = {}, provider: Variant = null) -> float:
	var resolved_provider: Variant = provider
	var judgement_dict := _as_dict(judgement)
	if not (judgement is Dictionary) and provider == null:
		resolved_provider = judgement
	var base_cost := _resource_float(action, "base_cost", 0.0)
	var judgement_mult := _judgement_channel_mult(judgement_dict, &"cost", "cost_mult", 1.0)
	var provider_mult := _provider_mult(resolved_provider, "cost_mult", action)
	return maxf(0.0, base_cost * judgement_mult * provider_mult)


static func resolve_reward(action: Resource, judgement: Variant = {}, provider: Variant = null) -> float:
	var judgement_dict := _as_dict(judgement)
	var reward := _resource_float(action, "base_reward", 0.0)
	var judgement_mult := _judgement_channel_mult(judgement_dict, &"reward", "reward_mult", 1.0)
	var provider_mult := _provider_mult(provider, "reward_mult", action)
	return maxf(0.0, reward * judgement_mult * provider_mult)


static func resolve_move(action: Resource, judgement: Variant = {}, burst: Variant = null) -> Vector2:
	var judgement_dict := _as_dict(judgement)
	var judgement_mult := _dict_float(judgement_dict, "move_mult", 1.0)
	var burst_mult := _provider_mult(burst, "move_mult", action)
	return Vector2(
		_resource_float(action, "move_mult_x", 0.0),
		_resource_float(action, "move_mult_y", 0.0)
	) * judgement_mult * burst_mult


static func resolve_knockback(action: Resource, judgement: Variant, base_knockback: Vector2, provider: Variant = null) -> Vector2:
	var judgement_dict := _as_dict(judgement)
	# 击退跟随伤害判定通道（good 0.85 / bad 0.7），可被 judgement 里的显式
	# knockback_mult 覆盖 —— 与 test_combat_manager_resolvers 的契约一致。
	var judgement_mult := _judgement_channel_mult(judgement_dict, &"damage", "knockback_mult", 1.0)
	var provider_mult := _provider_mult(provider, "knockback_mult", action)
	return Vector2(
		base_knockback.x * _resource_float(action, "knockback_mult_x", 0.0),
		base_knockback.y * _resource_float(action, "knockback_mult_y", 0.0)
	) * judgement_mult * provider_mult


static func resolve_action_snapshot(action: Resource, judgement: Variant = {}, provider: Variant = null) -> Dictionary:
	var resolved_provider: Variant = provider
	var judgement_dict := _as_dict(judgement)
	if not (judgement is Dictionary) and provider == null:
		resolved_provider = judgement
	return {
		"cost": resolve_cost(action, judgement_dict, resolved_provider),
		"reward": resolve_reward(action, judgement_dict, resolved_provider),
		"move": resolve_move(action, judgement_dict, resolved_provider),
		"startup_beats": _resolved_stat(action, "startup_beats", resolved_provider, 0.0),
		"active_beats": _resolved_stat(action, "active_beats", resolved_provider, 0.0),
		"recovery_beats": _resolved_stat(action, "recovery_beats", resolved_provider, 0.0),
	}


static func _judgement_channel_mult(judgement: Dictionary, channel: StringName, override_key: String, fallback: float) -> float:
	if _dict_has(judgement, override_key):
		return _dict_float(judgement, override_key, fallback)
	var label := _judgement_label(judgement)
	if label.is_empty() or JudgementPolicyResource == null or not JudgementPolicyResource.has_method("multiplier"):
		return fallback
	return float(JudgementPolicyResource.call("multiplier", label, channel, fallback))


static func _resource_float(resource: Resource, property_name: String, fallback: float) -> float:
	if resource == null:
		return fallback
	var value = resource.get(property_name)
	if value == null:
		return fallback
	return float(value)


static func _dict_float(values: Dictionary, key: String, fallback: float) -> float:
	if values.has(key):
		return float(values[key])
	var name_key := StringName(key)
	if values.has(name_key):
		return float(values[name_key])
	return fallback


static func _dict_has(values: Dictionary, key: String) -> bool:
	return values.has(key) or values.has(StringName(key))


static func _judgement_label(judgement: Dictionary) -> StringName:
	if judgement.has("label"):
		return StringName(str(judgement["label"]).to_lower())
	if judgement.has(&"label"):
		return StringName(str(judgement[&"label"]).to_lower())
	return &""


static func _as_dict(value: Variant) -> Dictionary:
	if value is Dictionary:
		return value
	return {}


static func _resolved_stat(action: Resource, property_name: String, provider: Variant, fallback: float) -> float:
	var base_value := _resource_float(action, property_name, fallback)
	return maxf(0.0, base_value * _provider_mult(provider, property_name, action))


static func _provider_mult(provider: Variant, method_name: String, action: Resource) -> float:
	if provider == null:
		return 1.0
	if provider.has_method(method_name):
		return float(provider.call(method_name, action))
	if provider.has_method("stat_multiplier"):
		return float(provider.call("stat_multiplier", StringName(method_name), action))
	return 1.0