## Dropped item entity — a single stack of one item type lying on the world floor.
##
## Render model:
##   For types in _ITEM_SPRITES (stone, wood, plank, iron_ore, gold, …) a Sprite2D
##   child draws the ElvGames icon. For all other types _draw() falls back to a
##   hue-hashed coloured square — the original Phase 4 placeholder kept around
##   for the long tail of items (cloth, meals, corpses, ash, etc.).
##   Quality border + stack-count badge are always drawn procedurally on top of
##   whichever base layer renders, so the sprite swap is purely additive.
##
## Item type constants mirror the 16 filter chips in docs/design.md. They are
## used by StockpileZone filter bitmasks and pawn-carry typing.
##
## World registration (World.register_item / World.unregister_item) is called
## here but the methods land in World during Opus integration. The script will
## parse cleanly; the call will fail at runtime until then.

class_name Item extends Node2D

const TILE_SIZE_PX: int = 16

## ElvGames FG_Abandoned_Mines icons used for the most-spawned item types.
## Picked in the 2026-05-12 visual pass — see /tmp/item_finals.png for the
## side-by-side that produced these atlas coords. Other types still fall back
## to the procedural hue-hashed square in _draw().
const _MINES_TEX: Texture2D = preload("res://art/tiles/FG_Abandoned_Mines.png")
const _ITEM_SPRITES: Dictionary = {
	&"stone":    {"tex": _MINES_TEX, "coord": Vector2i(5, 33)},
	&"iron_ore": {"tex": _MINES_TEX, "coord": Vector2i(9, 33)},
	&"gold":     {"tex": _MINES_TEX, "coord": Vector2i(13, 33)},
	&"wood":     {"tex": _MINES_TEX, "coord": Vector2i(20, 13)},
	&"plank":    {"tex": _MINES_TEX, "coord": Vector2i(28, 18)},
}

# ── canonical type registry — matches docs/design.md "16 filter chips" ───────

const TYPE_WOOD: StringName       = &"wood"         # Wd
const TYPE_STONE: StringName      = &"stone"        # St
const TYPE_IRON_ORE: StringName   = &"iron_ore"     # Ir
const TYPE_COPPER_ORE: StringName = &"copper_ore"   # Cu
const TYPE_SILVER: StringName     = &"silver"       # Ag
const TYPE_GOLD: StringName       = &"gold"         # Au
const TYPE_CLOTH: StringName      = &"cloth"        # Cl
const TYPE_VEGETABLE: StringName  = &"vegetable"    # Veg
const TYPE_MEAT: StringName       = &"meat"         # Mt
const TYPE_GRAIN: StringName      = &"grain"        # Gr
const TYPE_MEAL: StringName       = &"meal"         # Ck (cooked)
const TYPE_MEDICINE: StringName   = &"medicine"     # Md
const TYPE_TOOL: StringName       = &"tool"         # Tl
const TYPE_WEAPON: StringName     = &"weapon"       # Wp
const TYPE_ARMOR: StringName      = &"armor"        # Ar
const TYPE_CORPSE: StringName     = &"corpse"       # Co

# Phase 6 — intermediate crafted goods (carpenter bench + smelter outputs).
const TYPE_PLANK: StringName      = &"plank"
const TYPE_STONE_BLOCK: StringName = &"stone_block"

# Phase 7 — cooking chain. Grain → Flour (millstone) → Bread (hearth).
# TYPE_MEAL (&"meal") is the generic cooked-dish output and already lives above
# in the 16-chip base set.
const TYPE_FLOUR: StringName      = &"flour"
const TYPE_BREAD: StringName      = &"bread"

# Phase 14 — cremation output. One ash item drops per cremated corpse.
const TYPE_ASH: StringName        = &"ash"

const ALL_TYPES: Array[StringName] = [
	TYPE_WOOD, TYPE_STONE, TYPE_IRON_ORE, TYPE_COPPER_ORE,
	TYPE_SILVER, TYPE_GOLD, TYPE_CLOTH, TYPE_VEGETABLE,
	TYPE_MEAT, TYPE_GRAIN, TYPE_MEAL, TYPE_MEDICINE,
	TYPE_TOOL, TYPE_WEAPON, TYPE_ARMOR, TYPE_CORPSE,
	TYPE_PLANK, TYPE_STONE_BLOCK,
	TYPE_FLOUR, TYPE_BREAD,
	TYPE_ASH,
]

# ── quality system (docs/architecture.md "Quality system") ───────────────────
# Rolled at craft-completion; stored per item; drives border colour in _draw().
enum Quality { SHODDY, NORMAL, EXCELLENT, MASTERWORK, LEGENDARY }

# ── state ────────────────────────────────────────────────────────────────────

@export var item_type: StringName = TYPE_WOOD
@export var stack_size: int = 1
@export var quality: Quality = Quality.NORMAL

var tile: Vector2i = Vector2i.ZERO

## When true the on-floor visual is suppressed; the carrying pawn renders the
## carry indicator instead.
var being_carried: bool = false


# ── lifecycle ─────────────────────────────────────────────────────────────────

func _ready() -> void:
	position = _tile_to_world(tile)
	visible = not being_carried


func _exit_tree() -> void:
	World.unregister_item(self)


# ── public API ────────────────────────────────────────────────────────────────

## One-shot initialiser called by the spawning code (Tree.fell, Rock.mined, etc.)
## Sets all fields, syncs position, and registers with World.
func setup(p_type: StringName, p_stack: int, p_tile: Vector2i) -> void:
	item_type = p_type
	stack_size = p_stack
	tile = p_tile
	position = _tile_to_world(tile)
	visible = not being_carried
	_build_sprite()
	queue_redraw()
	World.register_item(self)
	Audit.log("item", "spawned %s×%d at %s" % [item_type, stack_size, tile])


## Hide/show the on-floor sprite when the pawn picks up or drops this item.
func set_being_carried(value: bool) -> void:
	being_carried = value
	visible = not being_carried


## Build the Sprite2D child for item_type, if a tileset icon is registered.
## Idempotent: re-running drops the previous sprite first. Types without an
## entry in _ITEM_SPRITES render via the procedural fallback in _draw().
func _build_sprite() -> void:
	var prev := get_node_or_null("Sprite")
	if prev != null:
		prev.queue_free()
	var data = _ITEM_SPRITES.get(item_type)
	if data == null:
		return
	var sprite := Sprite2D.new()
	sprite.name = "Sprite"
	sprite.texture = data["tex"]
	sprite.region_enabled = true
	var coord: Vector2i = data["coord"]
	sprite.region_rect = Rect2(coord.x * TILE_SIZE_PX, coord.y * TILE_SIZE_PX, TILE_SIZE_PX, TILE_SIZE_PX)
	sprite.centered = true
	# Item position is the tile centre — Sprite2D centred at (0, 0) fills the
	# 16×16 cell exactly. No bottom-anchoring offset (items are flat on the floor).
	sprite.offset = Vector2.ZERO
	sprite.z_index = 0
	add_child(sprite)


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

func to_dict() -> Dictionary:
	return {
		"class_id": &"item",
		"type": String(item_type),
		"stack_size": stack_size,
		"tile_x": tile.x,
		"tile_y": tile.y,
		"quality": int(quality),
	}


## Returns a plain Dictionary spec for World.load_items() to instantiate from.
## Items cannot reconstruct themselves standalone — they need a parent in the
## scene tree. World adds the node, then calls setup() from the returned dict.
static func from_dict(d: Dictionary) -> Dictionary:
	return {
		"type": StringName(d.get("type", "wood")),
		"stack_size": int(d.get("stack_size", 1)),
		"tile_x": int(d.get("tile_x", 0)),
		"tile_y": int(d.get("tile_y", 0)),
		"quality": int(d.get("quality", Quality.NORMAL)),
	}


# ── render ────────────────────────────────────────────────────────────────────

func _draw() -> void:
	# Two render paths: types in _ITEM_SPRITES are painted by the Sprite2D child
	# (built in setup()) — _draw() then only adds the quality border + stack
	# count badge on top. Other types still use the procedural hue square so
	# stockpile filtering remains visually unique while we expand the sprite set.
	var has_sprite: bool = _ITEM_SPRITES.has(item_type)
	var half: int = 6 if not has_sprite else 8  # border hugs the 16×16 sprite
	var square := Rect2(Vector2(-half, -half), Vector2(half * 2, half * 2))

	if not has_sprite:
		var hue := float(item_type.hash() % 360) / 360.0
		var fill := Color.from_hsv(hue, 0.6, 0.85)
		draw_rect(square, fill)
		draw_rect(square, Color(0.0, 0.0, 0.0, 0.75), false, 1.0)

	# Quality border — drawn over the dark outline (or sprite), colour per quality tier.
	# NORMAL has no extra border.
	match quality:
		Quality.SHODDY:
			draw_rect(square, Color(0.40, 0.40, 0.40), false, 1.0)
		Quality.EXCELLENT:
			draw_rect(square, Color(0.20, 0.55, 0.95), false, 1.0)
		Quality.MASTERWORK:
			draw_rect(square, Color(0.85, 0.55, 0.10), false, 1.0)
		Quality.LEGENDARY:
			draw_rect(square, Color(0.85, 0.10, 0.80), false, 2.0)
		_:
			pass  # NORMAL — no extra border

	# Stack count badge — bottom-right corner of the square, font_size 7.
	if stack_size > 1:
		var label := Strings.t(&"item.stack_count").format({"n": stack_size})
		draw_string(
			ThemeDB.fallback_font,
			Vector2(half - 1, half - 1),
			label,
			HORIZONTAL_ALIGNMENT_RIGHT,
			-1,
			7,
			Color(0.0, 0.0, 0.0, 0.6)  # drop-shadow offset below
		)
		draw_string(
			ThemeDB.fallback_font,
			Vector2(half - 2, half - 2),
			label,
			HORIZONTAL_ALIGNMENT_RIGHT,
			-1,
			7,
			Color(1.0, 1.0, 1.0, 1.0)
		)


# ── helpers ───────────────────────────────────────────────────────────────────

func _tile_to_world(t: Vector2i) -> Vector2:
	return Vector2(
		t.x * TILE_SIZE_PX + TILE_SIZE_PX / 2.0,
		t.y * TILE_SIZE_PX + TILE_SIZE_PX / 2.0
	)