## Rock entity — mineable by a pawn with a Mine job. Drops a stone Item node
## when mined out.
##
## Mirrors Tree's chopping model; stone is harder so MINE_TICKS is longer.
## A MineProvider (Opus, Phase 4) creates a Job whose INTERACT toil calls
## on_mine_tick() once per sim tick via JobRunner.
##
## World registration (World.register_rock / World.unregister_rock) is called
## here but the methods land in World during Opus integration.

class_name Rock extends Node2D

const TILE_SIZE_PX: int = 16

## Sim ticks to mine a rock at 1× speed (120 ticks = 6 sim seconds at 20 Hz).
## Stone is harder than wood — MINE_TICKS > Tree.CHOP_TICKS.
const MINE_TICKS: int = 120
## Stone Items dropped on a successful mine.
const STONE_DROPS_ON_MINE: int = 1

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

var tile: Vector2i = Vector2i.ZERO
## 0..MINE_TICKS. Advanced by on_mine_tick(); rock is mined when equal to MINE_TICKS.
var mine_progress: int = 0

# Preloaded scene for spawned stone items.
const ITEM_SCENE: PackedScene = preload("res://scenes/entities/item.tscn")


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

func _ready() -> void:
	position = _tile_to_world(tile)
	World.register_rock(self)


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


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

## One-shot initialiser. Call after add_child() so _ready() already fired.
func setup(start_tile: Vector2i) -> void:
	tile = start_tile
	mine_progress = 0
	position = _tile_to_world(tile)
	queue_redraw()
	Audit.log("rock", "spawned at %s" % tile)


## True when the rock hasn't been fully mined yet.
func is_mineable() -> bool:
	return mine_progress < MINE_TICKS


## Called by the INTERACT toil in JobRunner once per sim tick while the pawn
## works this rock. Advances mine_progress and triggers mined() when complete.
func on_mine_tick() -> void:
	if not is_mineable():
		return
	mine_progress += 1
	queue_redraw()
	if mine_progress >= MINE_TICKS:
		mined()


## Drop stone Item(s) and free this node. Called automatically by on_mine_tick()
## but also accessible for scripted removal (debug, storyteller events).
func mined() -> void:
	# Single drop lands on the rock's own tile.
	var item: Item = ITEM_SCENE.instantiate()
	get_parent().add_child(item)
	item.setup(Item.TYPE_STONE, 1, tile)
	Audit.log("rock", "mined at %s; %d stone drop" % [tile, STONE_DROPS_ON_MINE])
	queue_free()


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

func to_dict() -> Dictionary:
	return {
		"tile_x": tile.x,
		"tile_y": tile.y,
		"mine_progress": mine_progress,
	}


static func from_dict(d: Dictionary) -> Dictionary:
	return {
		"tile_x": int(d.get("tile_x", 0)),
		"tile_y": int(d.get("tile_y", 0)),
		"mine_progress": int(d.get("mine_progress", 0)),
	}


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

func _draw() -> void:
	# Angular cluster of 3–4 triangles in a dark-grey / light-grey palette.
	var c1 := Color(0.55, 0.55, 0.50)   # light face
	var c2 := Color(0.38, 0.38, 0.36)   # shadow face

	# Main body polygon (roughly an irregular hex).
	var body := PackedVector2Array([
		Vector2(-5.0, 3.0),
		Vector2(-6.0, -1.0),
		Vector2(-2.0, -6.0),
		Vector2(3.0, -5.0),
		Vector2(6.0, 0.0),
		Vector2(4.0, 4.0),
	])
	draw_colored_polygon(body, c1)

	# Shadow face on the bottom-right triangle to give depth.
	var shadow := PackedVector2Array([
		Vector2(3.0, -5.0),
		Vector2(6.0, 0.0),
		Vector2(4.0, 4.0),
		Vector2(-5.0, 3.0),
	])
	draw_colored_polygon(shadow, c2)

	# Outline.
	draw_polyline(body, Color(0.0, 0.0, 0.0, 0.5), 1.0)
	draw_line(body[5], body[0], Color(0.0, 0.0, 0.0, 0.5), 1.0)

	# Mine-progress crack: a dark jagged line on the face when partially mined.
	if mine_progress > 0:
		var ratio := float(mine_progress) / float(MINE_TICKS)
		var crack_len := ratio * 5.0
		draw_line(
			Vector2(-1.0, -2.0),
			Vector2(-1.0 + crack_len, 1.0),
			Color(0.15, 0.12, 0.10, 0.85),
			1.5
		)


# ── 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
	)