extends RefCounted

signal event_recorded(event: EconomicEventRecord)

const DEFAULT_RATE_WINDOW_TICKS := 200
const DEFAULT_TICKS_PER_DAY := 200.0
const FACT_RESERVED_FIELDS := [
	"schema_version",
	"event_id",
	"event_type",
	"tick",
	"actor_id",
	"source_id",
	"destination_id",
	"item_id",
	"amount",
	"action_name",
	"action_id",
	"required_amount",
	"world_position",
]

var events: Array[EconomicEventRecord] = []
var next_event_id := 0
var world_events := WorldEventStore.new()

var _events_by_id: Dictionary = {}
var _event_ids_by_actor: Dictionary = {}
var _event_ids_by_type: Dictionary = {}
var _event_ids_by_tick: Dictionary = {}
var _world_id := SimulationIds.REGIONAL_WORLD_BOSNIA
var _location_id := SimulationIds.REGIONAL_LOCATION_JAJCE


func configure_scope(world_id: StringName, location_id: StringName) -> bool:
	if world_id.is_empty() or location_id.is_empty():
		return false
	if not events.is_empty():
		return world_id == _world_id and location_id == _location_id
	_world_id = world_id
	_location_id = location_id
	world_events = WorldEventStore.new()
	return true


func get_scope() -> Dictionary:
	return {"world_id": _world_id, "location_id": _location_id}


func record_economic(
	tick: int,
	event_type: StringName,
	actor_id: int,
	source_id: StringName,
	destination_id: StringName,
	item_id: StringName,
	amount: float,
	world_position: Vector3 = Vector3.ZERO
) -> EconomicEventRecord:
	if amount <= 0.0:
		return null
	var event := EconomicEventRecord.create(
		next_event_id,
		event_type,
		tick,
		actor_id,
		source_id,
		destination_id,
		item_id,
		amount,
		world_position
	)
	_append(event)
	return event


func record_narrative(
	tick: int,
	event_type: StringName,
	actor_id: int,
	source_id: StringName = &"",
	action_display: String = "",
	world_position: Vector3 = Vector3.ZERO,
	action_id: StringName = &"",
	item_id: StringName = &"",
	required_amount: float = 0.0
) -> EconomicEventRecord:
	var event := EconomicEventRecord.create_narrative(
		next_event_id,
		event_type,
		tick,
		actor_id,
		source_id,
		action_display,
		world_position,
		action_id,
		item_id,
		required_amount
	)
	if event_type == SimulationIds.EVENT_TASK_BLOCKED:
		event.data["blocked_contract_kind"] = String(SimulationIds.BLOCKED_CONTRACT_ACTION_COST)
		event.data["world_id"] = String(_world_id)
		event.data["location_id"] = String(_location_id)
		var normalized := EconomicEventRecord.from_dictionary(event.to_dictionary())
		if normalized == null:
			return null
		event = normalized
	_append(event)
	return event


func record_fact(
	tick: int,
	event_type: StringName,
	actor_id: int,
	source_id: StringName = &"",
	destination_id: StringName = &"",
	fact_payload: Dictionary = {},
	world_position: Vector3 = Vector3.ZERO
) -> EconomicEventRecord:
	if tick < 0 or event_type.is_empty():
		return null
	var event := EconomicEventRecord.create_narrative(
		next_event_id, event_type, tick, actor_id, source_id, "", world_position
	)
	event.data["destination_id"] = String(destination_id)
	var payload_keys: Array = fact_payload.keys()
	payload_keys.sort_custom(
		func(first: Variant, second: Variant) -> bool: return str(first) < str(second)
	)
	var normalized_keys := {}
	for raw_key in payload_keys:
		if not raw_key is String and not raw_key is StringName:
			return null
		var key := String(raw_key)
		if key.is_empty() or key in FACT_RESERVED_FIELDS or normalized_keys.has(key):
			return null
		normalized_keys[key] = true
		event.data[key] = fact_payload[raw_key]
	var normalized := EconomicEventRecord.from_dictionary(event.to_dictionary())
	if normalized == null:
		return null
	if WorldEventRecord.from_economic_event(normalized, _world_id, _location_id) == null:
		return null
	_append(normalized)
	return normalized


func record_activity_completed(
	tick: int,
	actor_id: int,
	target_id: StringName,
	action_id: StringName,
	event_type_id: StringName,
	metric_id: StringName,
	metric_delta: float,
	world_position: Vector3 = Vector3.ZERO,
	cost_item_id: StringName = &"",
	cost_amount: float = 0.0
) -> EconomicEventRecord:
	if (
		tick < 0
		or actor_id < SimulationIds.PLAYER_ACTOR_ID
		or target_id.is_empty()
		or action_id.is_empty()
		or event_type_id.is_empty()
		or metric_id not in [&"safety", &"knowledge"]
		or not is_finite(metric_delta)
		or metric_delta <= 0.0
		or not world_position.is_finite()
		or not is_finite(cost_amount)
		or cost_amount < 0.0
		or (cost_item_id.is_empty() and cost_amount > 0.0)
		or (not cost_item_id.is_empty() and cost_amount <= 0.0)
	):
		return null
	var event := EconomicEventRecord.create_narrative(
		next_event_id,
		event_type_id,
		tick,
		actor_id,
		target_id,
		"",
		world_position,
		action_id,
		cost_item_id,
		cost_amount
	)
	event.data["metric_id"] = String(metric_id)
	event.data["metric_delta"] = metric_delta
	event.data["cost_item_id"] = String(cost_item_id)
	event.data["cost_amount"] = cost_amount
	event.data["target_kind"] = String(SimulationIds.TARGET_ACTIVITY)
	event.data["target_action_id"] = String(action_id)
	event.data["world_id"] = String(_world_id)
	event.data["location_id"] = String(_location_id)
	var normalized := EconomicEventRecord.from_dictionary(event.to_dictionary())
	if (
		normalized == null
		or (WorldEventRecord.from_economic_event(normalized, _world_id, _location_id) == null)
	):
		return null
	_append(normalized)
	return normalized


func record_activity_blocked(
	tick: int,
	actor_id: int,
	target_id: StringName,
	action_id: StringName,
	action_display: String,
	world_position: Vector3,
	cost_storage_id: StringName,
	cost_item_id: StringName,
	cost_amount: float
) -> EconomicEventRecord:
	var event := EconomicEventRecord.create_narrative(
		next_event_id,
		SimulationIds.EVENT_TASK_BLOCKED,
		tick,
		actor_id,
		cost_storage_id,
		action_display,
		world_position,
		action_id,
		cost_item_id,
		cost_amount
	)
	if target_id.is_empty():
		return null
	event.data["blocked_contract_kind"] = String(SimulationIds.BLOCKED_CONTRACT_ACTION_COST)
	event.data["world_id"] = String(_world_id)
	event.data["location_id"] = String(_location_id)
	event.data["activity_target_id"] = String(target_id)
	event.data["target_kind"] = String(SimulationIds.TARGET_ACTIVITY)
	event.data["target_action_id"] = String(action_id)
	var normalized := EconomicEventRecord.from_dictionary(event.to_dictionary())
	if (
		normalized == null
		or WorldEventRecord.from_economic_event(normalized, _world_id, _location_id) == null
	):
		return null
	_append(normalized)
	return normalized


func get_for_actor(actor_id: int, max_count: int = 8) -> Array[EconomicEventRecord]:
	var results: Array[EconomicEventRecord] = []
	var event_ids: Array = _event_ids_by_actor.get(actor_id, [])
	for index in range(event_ids.size() - 1, -1, -1):
		var event := get_by_id(int(event_ids[index]))
		if event == null:
			continue
		results.push_front(event)
		if results.size() >= max_count:
			break
	return results


func get_recent(max_count: int = 5) -> Array[EconomicEventRecord]:
	var results: Array[EconomicEventRecord] = []
	var start := maxi(events.size() - max_count, 0)
	for index in range(start, events.size()):
		results.append(events[index])
	return results


func get_by_id(event_id: int) -> EconomicEventRecord:
	return _events_by_id.get(event_id) as EconomicEventRecord


func get_by_ids(event_ids: Array[int]) -> Array[EconomicEventRecord]:
	var results: Array[EconomicEventRecord] = []
	for event_id in event_ids:
		var event := get_by_id(event_id)
		if event != null:
			results.append(event)
	return results


func get_for_type(event_type: StringName, max_count: int = 0) -> Array[EconomicEventRecord]:
	var results: Array[EconomicEventRecord] = []
	var event_ids: Array = _event_ids_by_type.get(event_type, [])
	var start := 0 if max_count <= 0 else maxi(event_ids.size() - max_count, 0)
	for index in range(start, event_ids.size()):
		var event := get_by_id(int(event_ids[index]))
		if event != null:
			results.append(event)
	return results


func get_for_tick(tick: int) -> Array[EconomicEventRecord]:
	var results: Array[EconomicEventRecord] = []
	for event_id in _event_ids_by_tick.get(tick, []):
		var event := get_by_id(int(event_id))
		if event != null:
			results.append(event)
	return results


func get_world_event(event_id: int) -> WorldEventRecord:
	return world_events.get_by_id(event_id)


func get_consumption_rates(
	current_tick: int,
	window_ticks: int = DEFAULT_RATE_WINDOW_TICKS,
	ticks_per_day: float = DEFAULT_TICKS_PER_DAY
) -> Dictionary:
	var consumed := {
		SimulationIds.RESOURCE_FOOD: 0.0,
		SimulationIds.RESOURCE_WOOD: 0.0,
	}
	var first_tick := maxi(current_tick - window_ticks, 0)
	for event in get_for_type(SimulationIds.EVENT_ITEM_CONSUMED):
		if int(event.data["tick"]) < first_tick:
			continue
		var item_id := StringName(event.data["item_id"])
		if consumed.has(item_id):
			consumed[item_id] = float(consumed[item_id]) + float(event.data["amount"])
	var elapsed := maxi(current_tick - first_tick, 1)
	return {
		"food_per_day": float(consumed[SimulationIds.RESOURCE_FOOD]) / elapsed * ticks_per_day,
		"wood_per_day": float(consumed[SimulationIds.RESOURCE_WOOD]) / elapsed * ticks_per_day,
	}


func restore(
	restored_events: Array[EconomicEventRecord],
	restored_next_id: int,
	restored_world_id: StringName = &"",
	restored_location_id: StringName = &""
) -> bool:
	if restored_world_id.is_empty() != restored_location_id.is_empty():
		return false
	events.clear()
	_events_by_id.clear()
	_event_ids_by_actor.clear()
	_event_ids_by_type.clear()
	_event_ids_by_tick.clear()
	if not restored_world_id.is_empty():
		_world_id = restored_world_id
		_location_id = restored_location_id
	world_events = WorldEventStore.new()
	for event in restored_events:
		_index(event)
	next_event_id = restored_next_id
	return true


func _append(event: EconomicEventRecord) -> void:
	next_event_id += 1
	_index(event)
	event_recorded.emit(event)


func _index(event: EconomicEventRecord) -> void:
	if event == null:
		return
	var event_id := int(event.data["event_id"])
	if _events_by_id.has(event_id):
		return
	events.append(event)
	_events_by_id[event_id] = event
	_append_index(_event_ids_by_actor, int(event.data["actor_id"]), event_id)
	_append_index(_event_ids_by_type, StringName(event.data["event_type"]), event_id)
	_append_index(_event_ids_by_tick, int(event.data["tick"]), event_id)
	var event_world_id := StringName(event.data.get("world_id", _world_id))
	var event_location_id := StringName(event.data.get("location_id", _location_id))
	if event_world_id.is_empty():
		event_world_id = _world_id
	if event_location_id.is_empty():
		event_location_id = _location_id
	world_events.append_economic(event, event_world_id, event_location_id)


static func _append_index(index: Dictionary, key: Variant, event_id: int) -> void:
	var event_ids: Array = index.get(key, [])
	event_ids.append(event_id)
	index[key] = event_ids