path: root/internal/game/map_test.go

package game

import (
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

	"thehouseoficarus/internal/color"
	"thehouseoficarus/internal/net"
	"thehouseoficarus/internal/player"
	"thehouseoficarus/internal/world"
)

func writeTempRoom(t *testing.T, dir string, id int, body string) {
	t.Helper()
	roomsDir := filepath.Join(dir, "rooms")
	if err := os.MkdirAll(roomsDir, 0755); err != nil {
		t.Fatal(err)
	}
	path := filepath.Join(roomsDir, strconv.Itoa(id)+".yaml")
	if err := os.WriteFile(path, []byte(body), 0644); err != nil {
		t.Fatal(err)
	}
}

// TestMapConnectorGlyphs verifies the directional link rendering: bidirectional
// links draw a bar, one-way links draw a directional arrow, outward-blocked
// links draw a blocked 'X', and links with no traversable direction draw 'X'.
func TestMapConnectorGlyphs(t *testing.T) {
	const condEast = "name: One\nexits:\n  east:\n    room: 2\n    condition:\n      flag: gate_open\n"
	const condSouth = "name: Three\nexits:\n  south:\n    room: 2\n    condition:\n      flag: gate_open\n"

	cases := []struct {
		name        string
		room1       string
		room2       string
		room3       string
		flagOpen    bool
		wantPresent string
		wantAbsent  []string
	}{
		{
			name:        "bidirectional bar",
			room1:       "name: One\nexits:\n  east: 2\n",
			room2:       "name: Two\nexits:\n  west: 1\n",
			wantPresent: "-",
			wantAbsent:  []string{"X", "<", ">"},
		},
		{
			name:        "one-way east arrow",
			room1:       "name: One\nexits:\n  east: 2\n",
			room2:       "name: Two\n",
			wantPresent: ">",
			wantAbsent:  []string{"X", "-", "<"},
		},
		{
			name:        "forward blocked, reverse open -> X (shortest path is blocked)",
			room1:       condEast,
			room2:       "name: Two\nexits:\n  west: 1\n",
			flagOpen:    false,
			wantPresent: "X",
			wantAbsent:  []string{"-", "<", ">"},
		},
		{
			name:        "forward blocked, reverse absent -> X",
			room1:       condEast,
			room2:       "name: Two\n",
			flagOpen:    false,
			wantPresent: "X",
			wantAbsent:  []string{"-", "<", ">"},
		},
		{
			name:        "conditional unblocked -> bar",
			room1:       condEast,
			room2:       "name: Two\nexits:\n  west: 1\n",
			flagOpen:    true,
			wantPresent: "-",
			wantAbsent:  []string{"X", "<", ">"},
		},
		{
			name: "outward open, inward blocked -> outward arrow (dist rules)",
			room1: "name: One\nexits:\n  east: 2\n",
			room2: "name: Two\nexits:\n  west: 1\n  north: 3\n",
			room3: condSouth,
			flagOpen: false,
			// dist[room1]=0, dist[room2]=1, dist[room3]=2.
			// Link 2↔3: near=2 (dist1), far=3 (dist2).
			// out = 2→north→3 = open → '^'
			wantPresent: "^",
			wantAbsent:  []string{"X", "v", "<", ">"},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			dir := t.TempDir()
			writeTempRoom(t, dir, 1, tc.room1)
			writeTempRoom(t, dir, 2, tc.room2)
			if tc.room3 != "" {
				writeTempRoom(t, dir, 3, tc.room3)
			}

			g := &Game{Deps: Deps{World: world.New(dir)}, Flags: NewFlagStore()}
			if tc.flagOpen {
				g.Flags.Set("gate_open", true)
			}
			sess := &net.Session{Player: &player.Player{Flags: map[string]any{}}}

			out := strings.Join(buildTinyMap(g, sess, 1, mapGlyphsForPlayer(false)), "\n")
			if !strings.Contains(out, tc.wantPresent) {
				t.Errorf("want %q present:\n%s", tc.wantPresent, out)
			}
			for _, a := range tc.wantAbsent {
				if strings.Contains(out, a) {
					t.Errorf("want %q absent:\n%s", a, out)
				}
			}
		})
	}
}

func TestBuildTinyMap(t *testing.T) {
	g := &Game{
		Deps: Deps{World: world.New("../../data")},
	}

	mg := mapGlyphsForPlayer(true)

	tests := []struct {
		name   string
		roomID int
		want   []string // expected lines, or nil to just check count
	}{
		{
			name:   "room 999991 has east exit",
			roomID: 999991,
		},
		{
			name:   "room 999992 has west/north/east",
			roomID: 999992,
		},
		{
			name:   "room 999994 has west/north/east",
			roomID: 999994,
		},
		{
			name:   "room 9999921 has west only",
			roomID: 9999921,
		},
		{
			name:   "room 9999922 west of town square",
			roomID: 9999922,
		},
		{
			name:   "room 9999925 east of south of west",
			roomID: 9999925,
		},
		{
			name:   "room 999998 hacking lab",
			roomID: 999998,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			lines := buildTinyMap(g, nil, tt.roomID, mg)
			if len(lines) != 7 {
				t.Fatalf("expected 7 lines, got %d", len(lines))
			}
			if lines[0] != "╔═════╗" {
				t.Errorf("line 0: want ╔═════╗, got %s", lines[0])
			}
			if lines[6] != "╚═════╝" {
				t.Errorf("line 6: want ╚═════╝, got %s", lines[6])
			}
			for i := 1; i <= 5; i++ {
				if !strings.HasPrefix(lines[i], "║") || !strings.HasSuffix(lines[i], "║") {
					t.Errorf("line %d: should have ║ borders, got %s", i, lines[i])
				}
				if color.VisibleLen(lines[i]) != 7 {
					t.Errorf("line %d: expected 7 visible runes, got %d in %q", i, color.VisibleLen(lines[i]), lines[i])
				}
			}
			t.Logf("Room %d map:\n%s", tt.roomID, strings.Join(lines, "\n"))
		})
	}
}

func TestWrapText(t *testing.T) {
	tests := []struct {
		text  string
		width int
		want  int // expected number of lines
	}{
		{"hello world", 70, 1},
		{"hello world", 5, 2},
		{"", 70, 0},
		{"a b c d e f g h i j", 5, 4},
	}

	for _, tt := range tests {
		result := wrapText(tt.text, tt.width)
		if len(result) != tt.want {
			t.Errorf("wrapText(%q, %d) = %d lines, want %d: %v", tt.text, tt.width, len(result), tt.want, result)
		}
	}
}

func TestBuildFullMap(t *testing.T) {
	g := &Game{
		Deps: Deps{World: world.New("../../data")},
	}

	mg := mapGlyphsForPlayer(true)

	tests := []struct {
		name   string
		roomID int
		width  int
		height int
	}{
		{"room 999991 30x20", 999991, 30, 20},
		{"room 999991 20x10", 999991, 20, 10},
		{"room 9999925 30x20", 9999925, 30, 20},
		{"min size 5x5", 999991, 5, 5},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			lines := buildFullMap(g, nil, tt.roomID, tt.width, tt.height, mg)
			if len(lines) != tt.height {
				t.Errorf("expected %d lines, got %d", tt.height, len(lines))
			}
			for i, line := range lines {
				if color.VisibleLen(line) != tt.width {
					t.Errorf("line %d: expected %d visible runes, got %d in %q", i, tt.width, color.VisibleLen(line), line)
				}
			}
			t.Logf("Room %d %dx%d map:\n%s", tt.roomID, tt.width, tt.height, strings.Join(lines, "\n"))
		})
	}
}

func TestStripBlankRows(t *testing.T) {
	input := []string{"  ", "hello", "", "  world  ", "   "}
	want := []string{"hello", "  world  "}
	got := stripBlankRows(input)
	if len(got) != len(want) {
		t.Fatalf("expected %d lines, got %d", len(want), len(got))
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("line %d: want %q, got %q", i, want[i], got[i])
		}
	}
}

func TestLeftTrimCommon(t *testing.T) {
	input := []string{"    hello", "    world", "  ", "  foo"}
	got := leftTrimCommon(input)
	// min leading spaces across non-blank lines: "    hello"=4, "    world"=4, "  foo"=2 → min=2
	// trim 2 from all lines
	if got[0] != "  hello" {
		t.Errorf("line 0: want %q, got %q", "  hello", got[0])
	}
	if got[1] != "  world" {
		t.Errorf("line 1: want %q, got %q", "  world", got[1])
	}
	if got[2] != "" {
		t.Errorf("line 2: want %q, got %q", "", got[2])
	}
	if got[3] != "foo" {
		t.Errorf("line 3: want %q, got %q", "foo", got[3])
	}
}

func TestLeftTrimCommonEmpty(t *testing.T) {
	input := []string{"   ", "", "   "}
	got := leftTrimCommon(input)
	if len(got) != 3 {
		t.Fatalf("expected 3 lines, got %d", len(got))
	}
}

func TestLeftTrimCommonZero(t *testing.T) {
	input := []string{"hello", "world"}
	got := leftTrimCommon(input)
	if got[0] != "hello" {
		t.Errorf("line 0: want %q, got %q", "hello", got[0])
	}
	if got[1] != "world" {
		t.Errorf("line 1: want %q, got %q", "world", got[1])
	}
}