package world

import (
	"os"
	"path/filepath"
	"testing"
)

func writeRoom(t *testing.T, dir string, body string) {
	t.Helper()
	rooms := filepath.Join(dir, "rooms")
	if err := os.MkdirAll(rooms, 0o755); err != nil {
		t.Fatal(err)
	}
	path := filepath.Join(rooms, "1001.yaml")
	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
		t.Fatal(err)
	}
}

func TestRoomObjectReferenceVsInline(t *testing.T) {
	dir := t.TempDir()
	body := `name: Test Room
objects:
  - id: workbench
  - name: window
    hidden: true
    description: "A small window."
  - id: control
    name: instrument panel
    aliases: [cockpit]
    description: "A panel."
`
	// rebuild the path index so LoadRoom can find the room file
	writeRoom(t, dir, body)
	w := New(dir)

	room, err := w.LoadRoom(1001)
	if err != nil {
		t.Fatalf("LoadRoom: %v", err)
	}
	if len(room.Objects) != 3 {
		t.Fatalf("expected 3 objects, got %d", len(room.Objects))
	}

	// reference
	if ref := room.Objects[0]; ref.Inline != nil || ref.ID != "workbench" {
		t.Errorf("object 0 should be a reference to workbench, got %+v (inline=%v)", ref, ref.Inline)
	}

	// inline, id derived from the normalized name
	in := room.Objects[1]
	if in.Inline == nil {
		t.Fatalf("object 1 should be inline")
	}
	if in.ID != "window" {
		t.Errorf("inline id should derive from name to %q, got %q", "window", in.ID)
	}
	if !in.Inline.Hidden || in.Inline.Name != "window" {
		t.Errorf("inline fields not parsed: %+v", in.Inline)
	}

	// inline with a multi-word name: id is the normalized name (spaces kept),
	// and an explicit `id:` is NOT used as identity (it is preserved on the
	// def only so validation can flag it).
	ex := room.Objects[2]
	if ex.Inline == nil {
		t.Fatalf("object 2 should be inline")
	}
	if ex.ID != "instrument panel" {
		t.Errorf("inline id should be normalized name %q, got %q", "instrument panel", ex.ID)
	}
	if ex.Inline.ID != "control" {
		t.Errorf("explicit id should be preserved on def for validation, got %q", ex.Inline.ID)
	}
	if len(ex.Inline.Aliases) != 1 || ex.Inline.Aliases[0] != "cockpit" {
		t.Errorf("inline aliases not parsed: %+v", ex.Inline.Aliases)
	}
}

func TestNormalizeObjectName(t *testing.T) {
	cases := map[string]string{
		"window":           "window",
		"Instrument Panel": "instrument panel",
		"  Safety  Card ":  "safety card",
	}
	for in, want := range cases {
		if got := NormalizeObjectName(in); got != want {
			t.Errorf("NormalizeObjectName(%q) = %q, want %q", in, got, want)
		}
	}
}