position_test.go

package chess

import (
	"reflect"
	"testing"
)

func TestPositionBinary(t *testing.T) {
	for _, fen := range validFENs {
		pos, err := decodeFEN(fen)
		if err != nil {
			t.Fatal(err)
		}
		b, err := pos.MarshalBinary()
		if err != nil {
			t.Fatal(err)
		}
		cp := &Position{}
		if err := cp.UnmarshalBinary(b); err != nil {
			t.Fatal(err)
		}
		if pos.String() != cp.String() {
			t.Fatalf("expected %s but got %s", pos.String(), cp.String())
		}
	}
}

func TestPositionUpdate(t *testing.T) {
	for _, fen := range validFENs {
		pos, err := decodeFEN(fen)
		if err != nil {
			t.Fatal(err)
		}

		{
			np := pos.Update(&pos.ValidMoves()[0])
			if pos.Turn().Other() != np.turn {
				t.Fatal("expected other turn")
			}
			if pos.halfMoveClock+1 != np.halfMoveClock {
				t.Fatal("expected half move clock increment")
			}
			if pos.board.String() == np.board.String() {
				t.Fatal("expected board update")
			}
		}

		{
			np := pos.Update(nil)
			if pos.Turn().Other() != np.turn {
				t.Fatal("expected other turn")
			}
			if pos.halfMoveClock+1 != np.halfMoveClock {
				t.Fatal("expected half move clock increment")
			}
			if pos.board.String() != np.board.String() {
				t.Fatal("expected same board")
			}
		}
	}
}

func TestPositionPly(t *testing.T) {
	tests := []struct {
		moveCount int
		turn      Color
		want      int
	}{
		{moveCount: 0, turn: White, want: 0},
		{moveCount: 1, turn: White, want: 1},
		{moveCount: 1, turn: Black, want: 2},
		{moveCount: 2, turn: White, want: 3},
		{moveCount: 2, turn: Black, want: 4},
		{moveCount: 10, turn: White, want: 19},
		{moveCount: 10, turn: Black, want: 20},
	}

	for _, tt := range tests {
		pos := &Position{
			moveCount: tt.moveCount,
			turn:      tt.turn,
		}
		got := pos.Ply()
		if got != tt.want {
			t.Errorf("Ply() with moveCount=%d, turn=%v: got %d, want %d", tt.moveCount, tt.turn, got, tt.want)
		}
	}
}

func TestSamePositionEnPassantFIDECompliance(t *testing.T) {
	// FIDE Article 9.2.3: positions are the same only if "the possible
	// moves of all the pieces are the same". Per Article 9.2.3.1, an en
	// passant square should only matter when a pawn could have been
	// captured en passant (i.e., the capture is actually possible).

	// Position with en passant square set but no pawn can capture:
	// White pawn on e4 (just pushed e2-e4), en passant square e3,
	// but no black pawn on d4 or f4 to capture.
	posWithIrrelevantEP, err := decodeFEN("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
	if err != nil {
		t.Fatal(err)
	}

	// Same board position but without en passant square set.
	posWithoutEP, err := decodeFEN("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
	if err != nil {
		t.Fatal(err)
	}

	// These should be considered the same position because no en passant
	// capture is possible (no black pawn on d4 or f4).
	if !posWithIrrelevantEP.samePosition(posWithoutEP) {
		t.Error("positions with irrelevant en passant square should be considered the same")
	}

	// Position where en passant IS possible:
	// White pawn on e4, black pawn on d4. En passant square e3.
	// Black pawn on d4 can capture en passant on e3.
	posWithRelevantEP, err := decodeFEN("rnbqkbnr/ppp1pppp/8/8/3pP3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
	if err != nil {
		t.Fatal(err)
	}

	// Same board but without en passant square.
	posWithRelevantNoEP, err := decodeFEN("rnbqkbnr/ppp1pppp/8/8/3pP3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
	if err != nil {
		t.Fatal(err)
	}

	// These should NOT be considered the same because the en passant
	// capture is actually possible.
	if posWithRelevantEP.samePosition(posWithRelevantNoEP) {
		t.Error("positions with relevant en passant square should be considered different")
	}

	// Test with black pawn on f4 (right side of e4 pawn).
	posWithRelevantEPRight, err := decodeFEN("rnbqkbnr/pppp1ppp/8/8/4Pp2/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
	if err != nil {
		t.Fatal(err)
	}

	posWithRelevantEPRightNoEP, err := decodeFEN("rnbqkbnr/pppp1ppp/8/8/4Pp2/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")
	if err != nil {
		t.Fatal(err)
	}

	if posWithRelevantEPRight.samePosition(posWithRelevantEPRightNoEP) {
		t.Error("positions with relevant en passant square (right adjacent pawn) should be considered different")
	}
}

func TestValidMovesUnsafeEquivalence(t *testing.T) {
	for _, fen := range validFENs {
		pos, err := decodeFEN(fen)
		if err != nil {
			t.Fatal(err)
		}
		safe := pos.ValidMoves()
		unsafe := pos.ValidMovesUnsafe()
		if !reflect.DeepEqual(safe, unsafe) {
			t.Fatalf("ValidMovesUnsafe() differs from ValidMoves() for FEN %s", fen)
		}
	}
}

func TestValidMovesUnsafeMutation(t *testing.T) {
	pos := StartingPosition()
	unsafe1 := pos.ValidMovesUnsafe()
	unsafe2 := pos.ValidMovesUnsafe()

	// Modifying the unsafe slice should affect the position's cached moves
	if len(unsafe1) == 0 {
		t.Fatal("expected non-zero moves")
	}
	original := unsafe1[0]
	unsafe1[0] = Move{s1: NoSquare, s2: NoSquare}
	if unsafe2[0].s1 != NoSquare || unsafe2[0].s2 != NoSquare {
		t.Error("modifying ValidMovesUnsafe() slice should affect internal cache")
	}

	// Reset for other tests
	unsafe1[0] = original
}

func TestValidMovesIter(t *testing.T) {
	for _, fen := range validFENs {
		pos, err := decodeFEN(fen)
		if err != nil {
			t.Fatal(err)
		}
		moves := pos.ValidMoves()
		var iterMoves []Move
		for move := range pos.ValidMovesIter {
			iterMoves = append(iterMoves, move)
		}
		if !reflect.DeepEqual(moves, iterMoves) {
			t.Fatalf("ValidMovesIter() yields different moves than ValidMoves() for FEN %s", fen)
		}
	}
}

func TestValidMovesIterEarlyReturn(t *testing.T) {
	pos := StartingPosition()
	count := 0
	for range pos.ValidMovesIter {
		count++
		if count == 5 {
			break
		}
	}
	if count != 5 {
		t.Fatalf("expected early return after 5 moves, got %d", count)
	}
}

func BenchmarkValidMovesCopy(b *testing.B) {
	pos := StartingPosition()
	for i := 0; i < b.N; i++ {
		_ = pos.ValidMoves()
	}
}

func BenchmarkValidMovesUnsafe(b *testing.B) {
	pos := StartingPosition()
	for i := 0; i < b.N; i++ {
		_ = pos.ValidMovesUnsafe()
	}
}

func TestZobristHashConsistency(t *testing.T) {
	// Same positions must have the same hash
	pos1 := StartingPosition()
	pos2 := StartingPosition()
	if pos1.ZobristHash() != pos2.ZobristHash() {
		t.Fatalf("identical positions have different hashes: %x vs %x", pos1.ZobristHash(), pos2.ZobristHash())
	}

	// Different positions should have different hashes (with very high probability)
	pos3, _ := decodeFEN("rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1")
	if pos1.ZobristHash() == pos3.ZobristHash() {
		t.Fatal("different positions have the same hash (unlikely collision)")
	}
}

func TestZobristHashIncrementalCorrectness(t *testing.T) {
	for _, fen := range validFENs {
		pos, err := decodeFEN(fen)
		if err != nil {
			t.Fatal(err)
		}
		moves := pos.ValidMovesUnsafe()
		if len(moves) == 0 {
			continue
		}
		for _, m := range moves {
			newPos := pos.Update(&m)
			// Recompute hash from scratch for the new position
			recomputedHash := newPos.computeHash()
			if newPos.ZobristHash() != recomputedHash {
				t.Fatalf("incremental hash %x != recomputed hash %x for move %s in FEN %s",
					newPos.ZobristHash(), recomputedHash, m.String(), fen)
			}
		}
	}
}

func TestZobristHashSamePositionEquivalence(t *testing.T) {
	// Test that hash-based samePosition matches the old logic for a variety of positions
	for i, fen1 := range validFENs {
		pos1, err := decodeFEN(fen1)
		if err != nil {
			t.Fatal(err)
		}
		for j, fen2 := range validFENs {
			if j > i+10 && j < len(validFENs)-10 {
				continue // Sample to keep test fast
			}
			pos2, err := decodeFEN(fen2)
			if err != nil {
				t.Fatal(err)
			}

			// The old samePosition logic (using string comparison)
			oldSame := pos1.board.String() == pos2.board.String() &&
				pos1.turn == pos2.turn &&
				pos1.castleRights.String() == pos2.castleRights.String() &&
				pos1.relevantEnPassantSquare() == pos2.relevantEnPassantSquare()

			newSame := pos1.samePosition(pos2)

			if oldSame != newSame {
				t.Fatalf("samePosition mismatch for FENs %s and %s: old=%v new=%v", fen1, fen2, oldSame, newSame)
			}
		}
	}
}

func BenchmarkSamePositionHash(b *testing.B) {
	pos1 := StartingPosition()
	pos2 := StartingPosition()
	for i := 0; i < b.N; i++ {
		_ = pos1.samePosition(pos2)
	}
}

func BenchmarkSamePositionString(b *testing.B) {
	pos1 := StartingPosition()
	pos2 := StartingPosition()
	for i := 0; i < b.N; i++ {
		_ = pos1.board.String() == pos2.board.String() &&
			pos1.turn == pos2.turn &&
			pos1.castleRights.String() == pos2.castleRights.String() &&
			pos1.relevantEnPassantSquare() == pos2.relevantEnPassantSquare()
	}
}