class_name Toil extends RefCounted
## A single atomic step within a Job — walk, wait, idle, etc.
##
## Save/load contract: every value in `data` MUST be JSON-safe.
## Vector2i is NOT JSON-safe in Godot 4 — tile coordinates are stored as
## "to_x"/"to_y" integer keys, never as Vector2i. get_walk_destination()
## reconstructs Vector2i on demand.
##
## Round-trip invariant:
##   var t2 := Toil.from_dict(t.to_dict())
##   assert(t2.kind == t.kind and t2.done == t.done and t2.data == t.data)

const KIND_WALK: StringName = &"walk"
const KIND_WAIT: StringName = &"wait"
const KIND_IDLE: StringName = &"idle"
const KIND_INTERACT: StringName = &"interact"  # Timed action on a target entity (Tree, Rock, …)
const KIND_PICKUP: StringName = &"pickup"       # Transfer Item at pawn.tile into pawn.carried_item
const KIND_DEPOSIT: StringName = &"deposit"     # Place pawn.carried_item at pawn.tile
const KIND_BUILD: StringName = &"build"         # Timed construction on a Wall / Floor / Door entity
const KIND_CRAFT: StringName = &"craft"         # Timed crafting at a Workbench driven by a Bill
const KIND_EAT: StringName = &"eat"             # Consume pawn.carried_item and restore hunger
const KIND_SLEEP: StringName = &"sleep"         # Sleep in a Bed (or on the floor) until pawn.sleep is full
const KIND_RESCUE: StringName = &"rescue"       # Marker: doctor has visited the downed pawn; single-tick no-op
const KIND_TREAT: StringName = &"treat"         # Multi-tick: apply medicine until patient HP ≥ revive threshold + no bleeding
const KIND_CLEAN: StringName = &"clean"         # Multi-tick: reduce dirt on a tile until clean (Phase 13 Cleaning category)
const KIND_PICKUP_CORPSE: StringName = &"pickup_corpse"   # Phase 14: pick up a Corpse entity at pawn.tile into pawn.carried_item
const KIND_DEPOSIT_CORPSE: StringName = &"deposit_corpse" # Phase 14: deliver pawn.carried_item (Corpse) into a GraveSlot at pawn.tile
const KIND_DEPOSIT_AT_WB: StringName = &"deposit_at_wb"  # Multi-ingredient: stash pawn.carried_item into the workbench's deposited_inputs buffer

var kind: StringName = KIND_IDLE
## Toil-specific params — all values must be int, float, bool, String, Dict, or Array.
var data: Dictionary = {}
## Set by JobRunner when this toil is complete.
var done: bool = false


# ── factories ────────────────────────────────────────────────────────────────

## Walk to the given tile. Stores coords as separate ints for JSON safety.
static func walk_to(tile: Vector2i) -> Toil:
	var t := Toil.new()
	t.kind = KIND_WALK
	t.data = {
		"to_x": tile.x,
		"to_y": tile.y,
		"started": false,
	}
	return t


## Pause for `n` sim ticks.
static func wait_ticks(n: int) -> Toil:
	var t := Toil.new()
	t.kind = KIND_WAIT
	t.data = {"ticks_remaining": n}
	return t


## Stand idle — never completes on its own; JobRunner must cancel or replace.
static func idle() -> Toil:
	var t := Toil.new()
	t.kind = KIND_IDLE
	t.data = {}
	return t


## Timed action on a scene-node target (Tree, Rock, …).
## `target_node_path` is the NodePath of the entity; stored as String for JSON safety.
## `tick_method` is the method to call each sim tick (e.g. "on_chop_tick").
## JobRunner resolves the node at first-tick and calls tick_method every sim tick
## until the target is no longer choppable/mineable (method source sets done via
## is_choppable() / is_mineable() returning false).
static func interact(target_node_path: NodePath, tick_method: StringName) -> Toil:
	var t := Toil.new()
	t.kind = KIND_INTERACT
	t.data = {
		"target": String(target_node_path),
		"tick_method": String(tick_method),
		"started": false,
	}
	return t


## Pick up an Item at pawn.tile into pawn.carried_item. Single-tick action.
## data is empty — the item is located at pawn.tile at execution time.
static func pickup() -> Toil:
	var t := Toil.new()
	t.kind = KIND_PICKUP
	t.data = {}
	return t


## Construction action on a scene-node target (Wall, Floor, Door, …).
## `target_node_path` is the NodePath of the entity; stored as String for JSON safety.
## JobRunner resolves the node at first-tick and calls on_build_tick() every sim tick
## until is_buildable() returns false (construction complete or site cancelled/removed).
static func build_at(target_node_path: NodePath) -> Toil:
	var t := Toil.new()
	t.kind = KIND_BUILD
	t.data = {
		"target": String(target_node_path),
		"started": false,
	}
	return t


## Place pawn.carried_item at pawn.tile. Single-tick action.
## data is empty — the item comes from pawn.carried_item at execution time.
static func deposit() -> Toil:
	var t := Toil.new()
	t.kind = KIND_DEPOSIT
	t.data = {}
	return t


## Consume pawn.carried_item and restore hunger.  Single-tick action.
## data is empty — the item comes from pawn.carried_item at execution time.
static func eat() -> Toil:
	var t := Toil.new()
	t.kind = KIND_EAT
	t.data = {}
	return t


## Sleep in the given Bed until pawn.sleep is full.
## `bed_path` is the NodePath of the Bed entity, stored as String for JSON safety.
## An empty string means "sleep on the floor" — no bed is claimed.
##
## data keys:
##   "bed"         — String(bed_path); empty means floor sleep.
##   "started"     — bool; false on first tick, true after claim resolved.
##   "ticks_slept" — int; incremented each tick for audit logging + emergency wake.
static func sleep_in_bed(bed_path: NodePath) -> Toil:
	var t := Toil.new()
	t.kind = KIND_SLEEP
	t.data = {
		"bed": String(bed_path),
		"started": false,
		"ticks_slept": 0,
	}
	return t


## Single-tick marker: the doctor has physically reached the downed patient.
## On execution the doctor visits the patient tile; the actual transport happens
## in the subsequent walk_to(bed) and treat toils.
##
## `patient_path` is the NodePath of the downed Pawn; stored as String for JSON safety.
##
## data keys:
##   "patient" — String(patient_path)
##   "started" — bool; set true on first tick so the match arm knows it fired.
static func rescue(patient_path: NodePath) -> Toil:
	var t := Toil.new()
	t.kind = KIND_RESCUE
	t.data = {
		"patient": String(patient_path),
		"started": false,
	}
	return t


## Multi-tick treatment of a downed pawn.
##
## First tick: snap the patient to the doctor's current tile (the medical-bed
## tile the doctor just walked to), mark started.
## Every tick: apply 0.5 HP of healing.  Clear the "bleeding" status every
## 100 ticks (Phase 9 simplification — full bleed cure in one pass; Phase 17
## may model severity reduction per tick).
## Done when patient.hp >= HP_REVIVE_THRESHOLD AND patient has no bleeding,
## or after 600 ticks (safety ceiling).
##
## `patient_path` is the NodePath of the patient Pawn; stored as String for JSON safety.
##
## data keys:
##   "patient"         — String(patient_path)
##   "started"         — bool; false until first tick
##   "ticks_treating"  — int; incremented each tick; safety ceiling at 600
static func treat(patient_path: NodePath) -> Toil:
	var t := Toil.new()
	t.kind = KIND_TREAT
	t.data = {
		"patient": String(patient_path),
		"started": false,
		"ticks_treating": 0,
	}
	return t


## Multi-tick cleaning action on a floor tile.
## `tile` is the Vector2i world-tile coordinate to clean; stored as int pair for JSON safety.
## JobRunner._tick_clean reduces DirtinessSystem.dirt_at(tile) by ~2.5/tick until dirt <= 0
## (40 base ticks per tile; Phase 17 may add skill bonus).
##
## data keys:
##   "clean_x" / "clean_y" — tile coords (ints, JSON-safe)
##   "started"             — bool; false until first tick
static func clean_at(tile: Vector2i) -> Toil:
	var t := Toil.new()
	t.kind = KIND_CLEAN
	t.data = {
		"clean_x": tile.x,
		"clean_y": tile.y,
		"started": false,
	}
	return t


## Phase 14 — pick up a Corpse entity lying at pawn.tile into pawn.carried_item.
## Single-tick. Scans World.corpses for a corpse at pawn.tile that is not already
## being carried (checks corpse.get("being_carried_corpse", false)).
static func pickup_corpse() -> Toil:
	var t := Toil.new()
	t.kind = KIND_PICKUP_CORPSE
	t.data = {}
	return t


## Phase 14 — deliver pawn.carried_item (a Corpse) into the GraveSlot at pawn.tile.
## Single-tick. Resolves the GraveSlot from World.stockpiles covering pawn.tile,
## calls slot.accept_corpse(corpse, world_parent) to finalise burial.
static func deposit_corpse() -> Toil:
	var t := Toil.new()
	t.kind = KIND_DEPOSIT_CORPSE
	t.data = {}
	return t


## Stash pawn.carried_item into the workbench's deposited_inputs buffer.
## Used as the first leg of a two-ingredient craft: pawn carries ingredient1
## here, deposits it into the workbench's buffer, then fetches ingredient2.
## `workbench_path` is the NodePath of the Workbench entity (String, JSON-safe).
##
## data keys:
##   "workbench" — String(workbench_path)
static func deposit_at_wb(workbench_path: NodePath) -> Toil:
	var t := Toil.new()
	t.kind = KIND_DEPOSIT_AT_WB
	t.data = {"workbench": String(workbench_path)}
	return t


## Timed crafting action at a Workbench.
## `workbench_path` is the NodePath of the Workbench entity (stored as String for JSON safety).
## `bill_index` is the index into workbench.bills that this toil should run.
## JobRunner resolves the workbench and bill on the first tick, validates pawn position and
## carried ingredient, then advances workbench.current_work_progress each tick until
## bill.recipe.work_ticks is reached — at which point the ingredient is consumed, an output
## Item is spawned with a quality roll, and bill.record_completion() is called.
static func craft_at(workbench_path: NodePath, bill_index: int) -> Toil:
	var t := Toil.new()
	t.kind = KIND_CRAFT
	t.data = {
		"workbench": String(workbench_path),
		"bill_index": bill_index,
		"started": false,
	}
	return t


# ── save / load ──────────────────────────────────────────────────────────────

func to_dict() -> Dictionary:
	return {
		"kind": str(kind),
		"data": data.duplicate(true),
		"done": done,
	}


static func from_dict(d: Dictionary) -> Toil:
	var t := Toil.new()
	t.kind = StringName(d.get("kind", str(KIND_IDLE)))
	t.data = (d.get("data", {}) as Dictionary).duplicate(true)
	t.done = d.get("done", false)
	return t


# ── convenience ──────────────────────────────────────────────────────────────

## Rebuild Vector2i from the JSON-safe int fields. Only valid for KIND_WALK.
func get_walk_destination() -> Vector2i:
	return Vector2i(data.get("to_x", 0), data.get("to_y", 0))
