class_name SupplyAutoPurchasePlans
extends RefCounted

## Owned player intent and the last actual attempt. No plan is inferred on load.
## Current catalogue prices/storage are reused; target stock is player input.
const Catalog := preload("res://scripts/supply/supply_catalog.gd")
const SNAPSHOT_VERSION := 1
const RECEIPT_PREFIX := "supply_purchase.auto.v1:"
const MAX_SIGNED_INT_TEXT := "9223372036854775807"
const RESULT_PURCHASED := &"PURCHASED"
const FAILED_RESULTS: Array[StringName] = [
	&"INVENTORY_ERROR", &"PAYMENT_FAILED", &"INSUFFICIENT_FUNDS", &"STORAGE_FULL",
	&"FACILITY_CLOSED", &"INVALID_QUANTITY", &"ITEM_NOT_PURCHASABLE", &"NOT_WAREHOUSE",
	&"REPLAY_MISMATCH",
]

var last_error := ""
var _plans: Dictionary = {}


func get_plan(warehouse_id: StringName, item_id: StringName) -> Dictionary:
	if _plans.has(warehouse_id) and (_plans[warehouse_id] as Dictionary).has(item_id):
		return (_plans[warehouse_id][item_id] as Dictionary).duplicate(true)
	return _empty_plan(warehouse_id, item_id)


func get_plans() -> Array[Dictionary]:
	var rows: Array[Dictionary] = []
	for warehouse_id: StringName in _sorted_names(_plans):
		for item_id: StringName in _sorted_names(_plans[warehouse_id]):
			rows.append(get_plan(warehouse_id, item_id))
	return rows


func set_plan(warehouse_id: StringName, item_id: StringName, enabled: bool,
	target_stock: int, facilities: FacilityService) -> Dictionary:
	var validation := validate_intent(warehouse_id, item_id, enabled, target_stock, facilities)
	if not bool(validation[&"ok"]):
		return validation
	var plan := get_plan(warehouse_id, item_id)
	plan[&"enabled"] = enabled
	plan[&"target_stock"] = target_stock
	if not _plans.has(warehouse_id):
		_plans[warehouse_id] = {}
	_plans[warehouse_id][item_id] = plan
	last_error = ""
	return {&"ok": true, &"plan": plan.duplicate(true)}


func record_attempt(warehouse_id: StringName, item_id: StringName, minute: int,
	result: CommandResult, economy: EconomyService) -> bool:
	if not _plans.has(warehouse_id) or not (_plans[warehouse_id] as Dictionary).has(item_id):
		return false
	var plan: Dictionary = _plans[warehouse_id][item_id]
	if minute < 0 or minute <= int(plan[&"last_attempt_minute"]):
		return false
	var reason: StringName = RESULT_PURCHASED if result.is_success() \
		else StringName(result.details.get(&"reason", &"PAYMENT_FAILED"))
	if reason != RESULT_PURCHASED and reason not in FAILED_RESULTS:
		return false
	var transaction_id := StringName(result.details.get(&"transaction_id", &"")) if result.is_success() else &""
	var quantity: int = int(result.details.get(&"quantity", 0)) if result.is_success() else 0
	var unit_price: int = int(result.details.get(&"unit_price", 0)) if result.is_success() else 0
	var total_cost: int = int(result.details.get(&"total_cost", 0)) if result.is_success() else 0
	if result.is_success() and (not valid_charge(quantity, unit_price, total_cost) or not valid_receipt(economy, warehouse_id, item_id, minute, transaction_id, total_cost, quantity, unit_price)):
		return false
	plan[&"last_attempt_minute"] = minute
	plan[&"last_result"] = reason
	plan[&"last_transaction_id"] = String(transaction_id)
	plan[&"last_quantity"] = quantity
	plan[&"last_unit_price"] = unit_price
	plan[&"last_total_cost"] = total_cost
	return true


func remove_warehouse(warehouse_id: StringName) -> void:
	_plans.erase(warehouse_id)


func create_snapshot() -> Dictionary:
	return {&"version": SNAPSHOT_VERSION, &"plans": get_plans()}


func restore_snapshot(snapshot: Dictionary, facilities: FacilityService,
	economy: EconomyService, minute: int) -> bool:
	last_error = ""
	if not _keys_match(snapshot, [&"version", &"plans"]) \
		or typeof(snapshot[&"version"]) != TYPE_INT or snapshot[&"version"] != SNAPSHOT_VERSION \
		or not snapshot[&"plans"] is Array or facilities == null or economy == null or minute < 0:
		return _restore_failure("Invalid automatic purchase snapshot.")
	# At most one plan per real warehouse/catalog item; input cannot broaden it.
	var maximum_rows := facilities.get_instances().size() * Catalog.get_purchase_items().size()
	if (snapshot[&"plans"] as Array).size() > maximum_rows:
		return _restore_failure("Too many automatic purchase plans.")
	var candidate: Dictionary = {}
	for value: Variant in snapshot[&"plans"]:
		if not value is Dictionary:
			return _restore_failure("Automatic purchase row is not a Dictionary.")
		var row: Dictionary = value
		if not _keys_match(row, [&"warehouse_id", &"item_id", &"enabled", &"target_stock",
			&"last_attempt_minute", &"last_result", &"last_transaction_id", &"last_quantity", &"last_unit_price", &"last_total_cost"]) \
			or typeof(row[&"warehouse_id"]) != TYPE_STRING or typeof(row[&"item_id"]) != TYPE_STRING \
			or not _text(row[&"warehouse_id"]) or not _text(row[&"item_id"]) \
			or typeof(row[&"enabled"]) != TYPE_BOOL or typeof(row[&"target_stock"]) != TYPE_INT \
			or typeof(row[&"last_attempt_minute"]) != TYPE_INT \
			or typeof(row[&"last_result"]) != TYPE_STRING_NAME \
			or typeof(row[&"last_transaction_id"]) != TYPE_STRING \
			or typeof(row[&"last_quantity"]) != TYPE_INT or typeof(row[&"last_unit_price"]) != TYPE_INT or typeof(row[&"last_total_cost"]) != TYPE_INT:
			return _restore_failure("Invalid automatic purchase row fields/types.")
		var warehouse_id := StringName(row[&"warehouse_id"])
		var item_id := StringName(row[&"item_id"])
		if not bool(validate_intent(warehouse_id, item_id, row[&"enabled"], row[&"target_stock"], facilities)[&"ok"]):
			return _restore_failure("Automatic purchase plan does not match its warehouse/catalog.")
		if candidate.has(warehouse_id) and (candidate[warehouse_id] as Dictionary).has(item_id):
			return _restore_failure("Duplicate automatic purchase plan.")
		var attempted := int(row[&"last_attempt_minute"])
		var reason: StringName = row[&"last_result"]
		var transaction_id := StringName(row[&"last_transaction_id"])
		var quantity: int = row[&"last_quantity"]
		var unit_price: int = row[&"last_unit_price"]
		var total_cost: int = row[&"last_total_cost"]
		if reason == RESULT_PURCHASED and not valid_charge(quantity, unit_price, total_cost):
			return _restore_failure("Saved automatic purchase quote is invalid.")
		if reason != RESULT_PURCHASED and (quantity != 0 or unit_price != 0 or total_cost != 0):
			return _restore_failure("Unpurchased automatic intent retained a charge.")
		if attempted < -1 or attempted > minute \
			or (attempted == -1 and (not reason.is_empty() or not transaction_id.is_empty())) \
			or (attempted >= 0 and reason != RESULT_PURCHASED and reason not in FAILED_RESULTS):
			return _restore_failure("Invalid automatic purchase attempt state.")
		if attempted >= 0:
			var paid_id := economy.get_transaction_id_for_idempotency_key(order_key(warehouse_id, item_id, attempted))
			if reason == RESULT_PURCHASED:
				if not valid_receipt(economy, warehouse_id, item_id, attempted, transaction_id, total_cost, quantity, unit_price):
					return _restore_failure("Automatic purchase receipt differs from its unique ledger transaction.")
			elif not transaction_id.is_empty() or (not paid_id.is_empty() and (reason != &"REPLAY_MISMATCH" or valid_receipt(economy, warehouse_id, item_id, attempted, paid_id))):
				return _restore_failure("Failed automatic purchase retained its own payment.")
		if not candidate.has(warehouse_id):
			candidate[warehouse_id] = {}
		candidate[warehouse_id][item_id] = row.duplicate(true)
	_plans = candidate
	return true


static func receipt_memo(item_id: StringName, quantity: int, unit_price: int, total_cost: int) -> StringName:
	if String(item_id).strip_edges().is_empty() or not valid_charge(quantity, unit_price, total_cost):
		return &""
	# Character length, not delimiter escaping, keeps arbitrary item punctuation
	# unambiguous. Only automatic payments use this immutable historical quote.
	return StringName(RECEIPT_PREFIX + "%d:%s:%d:%d:%d" % [
		String(item_id).length(), item_id, quantity, unit_price, total_cost])


static func decode_receipt_memo(memo: StringName) -> Dictionary:
	var text := String(memo)
	if not text.begins_with(RECEIPT_PREFIX): return {}
	var body := text.substr(RECEIPT_PREFIX.length())
	var delimiter := body.find(":")
	if delimiter <= 0: return {}
	var item_length := _positive_decimal(body.substr(0, delimiter))
	var remainder := body.substr(delimiter + 1)
	if item_length <= 0 or item_length >= remainder.length() or remainder.substr(item_length, 1) != ":":
		return {}
	var item_text := remainder.substr(0, item_length)
	if item_text.strip_edges().is_empty(): return {}
	var amounts := remainder.substr(item_length + 1).split(":", true)
	if amounts.size() != 3: return {}
	var quantity := _positive_decimal(amounts[0])
	var unit_price := _positive_decimal(amounts[1])
	var total_cost := _positive_decimal(amounts[2])
	if not valid_charge(quantity, unit_price, total_cost) \
		or receipt_memo(StringName(item_text), quantity, unit_price, total_cost) != memo:
		return {}
	return {&"item_id": item_text, &"quantity": quantity, &"unit_price": unit_price, &"total_cost": total_cost}


static func receipt_from_ledger(economy: EconomyService, warehouse_id: StringName,
	item_id: StringName, minute: int, transaction_id: StringName) -> Dictionary:
	if economy == null or transaction_id.is_empty() \
		or economy.get_transaction_id_for_idempotency_key(order_key(warehouse_id, item_id, minute)) != transaction_id:
		return {}
	var entries: Array = economy.get_transaction_entries(transaction_id)
	if entries.size() != 1: return {}
	var entry: LedgerEntry = entries[0]
	var receipt := decode_receipt_memo(entry.memo_key)
	if receipt.is_empty() or receipt[&"item_id"] != String(item_id) \
		or entry.absolute_minute != minute or entry.source_entity_id != warehouse_id \
		or entry.category != &"OPERATING_EXPENSE" or not entry.related_transaction_id.is_empty() \
		or entry.credit_account != &"PLAYER_CASH" or entry.debit_account != &"OPERATING_EXPENSE" \
		or entry.amount != receipt[&"total_cost"]:
		return {}
	return receipt


static func valid_receipt(economy: EconomyService, warehouse_id: StringName,
	item_id: StringName, minute: int, transaction_id: StringName, total_cost: int = -1,
	quantity: int = -1, unit_price: int = -1) -> bool:
	var receipt := receipt_from_ledger(economy, warehouse_id, item_id, minute, transaction_id)
	return not receipt.is_empty() and (total_cost < 0 or receipt[&"total_cost"] == total_cost) \
		and (quantity < 0 or receipt[&"quantity"] == quantity) \
		and (unit_price < 0 or receipt[&"unit_price"] == unit_price)


static func _positive_decimal(text: String) -> int:
	# Validate textual range before to_int: no float conversion or saturating
	# overflow can reinterpret a corrupt receipt as another positive amount.
	if text.is_empty() or text.length() > MAX_SIGNED_INT_TEXT.length() or text.substr(0, 1) == "0":
		return 0
	for index: int in text.length():
		var code := text.unicode_at(index)
		if code < 48 or code > 57: return 0
	if text.length() == MAX_SIGNED_INT_TEXT.length() and text > MAX_SIGNED_INT_TEXT: return 0
	return text.to_int()


static func valid_charge(quantity: int, unit_price: int, total_cost: int) -> bool:
	# Existing purchase input ceiling; division avoids multiplication overflow.
	@warning_ignore("integer_division")
	return quantity > 0 and quantity <= 10000 and unit_price > 0 and total_cost > 0 and total_cost / quantity == unit_price and total_cost % quantity == 0


static func validate_intent(warehouse_id: StringName, item_id: StringName, enabled: bool,
	target_stock: int, facilities: FacilityService) -> Dictionary:
	var facility: FacilityInstance = facilities.get_instance(warehouse_id) if facilities != null else null
	if facility == null or facility.definition_id != &"warehouse":
		return {&"ok": false, &"reason": &"NOT_WAREHOUSE"}
	var item := Catalog.get_item(item_id)
	if item.is_empty() or not bool(item.get(&"purchasable", false)):
		return {&"ok": false, &"reason": &"ITEM_NOT_PURCHASABLE"}
	var maximum := maximum_target(warehouse_id, item_id, facilities)
	if target_stock < 0 or target_stock > maximum or (enabled and target_stock == 0):
		return {&"ok": false, &"reason": &"INVALID_TARGET", &"maximum_target": maximum}
	return {&"ok": true, &"maximum_target": maximum}


static func maximum_target(warehouse_id: StringName, item_id: StringName, facilities: FacilityService) -> int:
	var facility: FacilityInstance = facilities.get_instance(warehouse_id) if facilities != null else null
	var item := Catalog.get_item(item_id)
	if facility == null or facility.definition_id != &"warehouse" or item.is_empty() \
		or not bool(item.get(&"purchasable", false)) or int(item.get(&"unit_weight", 0)) <= 0:
		return 0
	@warning_ignore("integer_division")
	return Catalog.storage_capacity(facility.definition_id) / int(item[&"unit_weight"])


static func order_key(warehouse_id: StringName, item_id: StringName, minute: int) -> StringName:
	# Length encoding avoids punctuation collisions. This is not a command ID.
	return StringName("supply.auto.%d:%s.%d:%s.%d" % [
		String(warehouse_id).length(), warehouse_id, String(item_id).length(), item_id, minute])


static func _empty_plan(warehouse_id: StringName, item_id: StringName) -> Dictionary:
	return {&"warehouse_id": String(warehouse_id), &"item_id": String(item_id), &"enabled": false,
		&"target_stock": 0, &"last_attempt_minute": -1, &"last_result": &"", &"last_transaction_id": "", &"last_quantity": 0, &"last_unit_price": 0, &"last_total_cost": 0}


static func _sorted_names(values: Dictionary) -> Array[StringName]:
	var ids: Array[StringName] = []
	for value: Variant in values: ids.append(StringName(value))
	ids.sort_custom(func(a: StringName, b: StringName) -> bool: return String(a) < String(b))
	return ids


static func _keys_match(value: Dictionary, expected: Array[StringName]) -> bool:
	if value.size() != expected.size(): return false
	for key: Variant in value:
		if typeof(key) != TYPE_STRING_NAME or key not in expected: return false
	return true


static func _text(value: Variant) -> bool:
	return typeof(value) in [TYPE_STRING, TYPE_STRING_NAME] and not String(value).strip_edges().is_empty()


func _restore_failure(message: String) -> bool:
	last_error = message
	return false