fix: pgn disambiguation squares (#75)

* fix: implement full square disambiguation for PGN parsing

* fix: remove redundant full square disambiguation logic in PGN parsing

* fix: add support for full square disambiguation in PGN parsing

* fix: remove unused nextToken function from PGN parser

* Update lexer.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update lexer.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fix: correct expected token types for queen with full square disambiguation test

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: CorentinGS

lexer.go

@@ -31,35 +31,36 @@ type TokenType int
 const (
 	EOF TokenType = iota
 	Undefined
-	TagStart        // [
-	TagEnd          // ]
-	TagKey          // The key part of a tag (e.g., "Site")
-	TagValue        // The value part of a tag (e.g., "Internet")
-	MoveNumber      // 1, 2, 3, etc.
-	DOT             // .
-	ELLIPSIS        // ...
-	PIECE           // N, B, R, Q, K
-	SQUARE          // e4, e5, etc.
-	CommentStart    // {
-	CommentEnd      // }
-	COMMENT         // The comment text
-	RESULT          // 1-0, 0-1, 1/2-1/2, *
-	CAPTURE         // 'x' in moves
-	FILE            // a-h in moves when used as disambiguation
-	RANK            // 1-8 in moves when used as disambiguation
-	KingsideCastle  // 0-0
-	QueensideCastle // 0-0-0
-	PROMOTION       // = in moves
-	PromotionPiece  // The piece being promoted to (Q, R, B, N)
-	CHECK           // + in moves
-	CHECKMATE       // # in moves
-	NAG             // Numeric Annotation Glyph (e.g., $1, $2, etc.)
-	VariationStart  // ( for starting a variation
-	VariationEnd    // ) for ending a variation
-	CommandStart    // [%
-	CommandName     // The command name (e.g., clk, eval)
-	CommandParam    // Command parameter
-	CommandEnd      // ]
+	TagStart            // [
+	TagEnd              // ]
+	TagKey              // The key part of a tag (e.g., "Site")
+	TagValue            // The value part of a tag (e.g., "Internet")
+	MoveNumber          // 1, 2, 3, etc.
+	DOT                 // .
+	ELLIPSIS            // ...
+	PIECE               // N, B, R, Q, K
+	SQUARE              // e4, e5, etc.
+	CommentStart        // {
+	CommentEnd          // }
+	COMMENT             // The comment text
+	RESULT              // 1-0, 0-1, 1/2-1/2, *
+	CAPTURE             // 'x' in moves
+	FILE                // a-h in moves when used as disambiguation
+	RANK                // 1-8 in moves when used as disambiguation
+	KingsideCastle      // 0-0
+	QueensideCastle     // 0-0-0
+	PROMOTION           // = in moves
+	PromotionPiece      // The piece being promoted to (Q, R, B, N)
+	CHECK               // + in moves
+	CHECKMATE           // # in moves
+	NAG                 // Numeric Annotation Glyph (e.g., $1, $2, etc.)
+	VariationStart      // ( for starting a variation
+	VariationEnd        // ) for ending a variation
+	CommandStart        // [%
+	CommandName         // The command name (e.g., clk, eval)
+	CommandParam        // Command parameter
+	CommandEnd          // ]
+	DeambiguationSquare // Full square disambiguation (e.g., e8 in Qe8f7)
 )
 
 func (t TokenType) String() string {
@@ -317,6 +318,7 @@ func (l *Lexer) readPieceMove() Token {
 
 func (l *Lexer) readMove() Token {
 	const disambiguationLength = 3
+	const disambiguationSquareLength = 4
 
 	position := l.position
 
@@ -348,6 +350,17 @@ func (l *Lexer) readMove() Token {
 	// Get the total length of what we read
 	length := l.position - position
 
+	// Handle full square disambiguation (e.g., "e8f7" -> "e8" then "f7")
+	if length == disambiguationSquareLength &&
+		isFile(l.input[position]) && isDigit(l.input[position+1]) &&
+		isFile(l.input[position+2]) && isDigit(l.input[position+3]) {
+		// Reset to return just the first square
+		l.position = position + 2
+		l.readPosition = position + 3
+		l.ch = l.input[l.position] // set current char to the first character of the second square
+		return Token{Type: DeambiguationSquare, Value: l.input[position : position+2]}
+	}
+
 	// If we read 3 characters, first one is disambiguation
 	if length == disambiguationLength {
 		l.readPosition = position + 1

pgn.go

@@ -338,11 +338,20 @@ func (p *Parser) parseMove() (*Move, error) {
 		} else if p.currentToken().Type == RANK {
 			moveData.originRank = p.currentToken().Value
 			p.advance()
+		} else if p.currentToken().Type == DeambiguationSquare {
+			// Full square disambiguation (e.g., "Qe8f7" -> piece: Q, origin: e8, dest: f7)
+			originSquare := p.currentToken().Value
+			if len(originSquare) == 2 {
+				moveData.originFile = string(originSquare[0])
+				moveData.originRank = string(originSquare[1])
+			}
+			p.advance()
 		}
 
 	case FILE:
 		moveData.originFile = p.currentToken().Value
 		p.advance()
+
 	}
 
 	// Handle capture

pgn_disambiguation_test.go

@@ -0,0 +1,125 @@
+package chess
+
+import (
+	"strings"
+	"testing"
+)
+
+// Test cases for PGN disambiguation parsing issue #73
+// The issue is that moves like "Qe8f7" (queen from e8 to f7) fail to parse
+// because the parser doesn't handle full square disambiguation properly.
+
+func TestPGNDisambiguationSquares(t *testing.T) {
+	tests := []struct {
+		name        string
+		pgn         string
+		shouldFail  bool
+		description string
+	}{
+		{
+			name:        "multiple_pieces_same_type_complex",
+			pgn:         `1. h4 d6 2. g4 Kd7 3. f4 Kc6 4. f5 Kd7 5. g5 Ke8 6. h5 Kd7 7. h6 Kc6 8. g6 Kb6 9. f6 Kc6 10. hxg7 Kd7 11. gxf7 Kc6 12. fxe7 Kb6 13. gxf8=Q Kc6 14. fxg8=Q Kb6 15. e8=Q Ka6 16. Qfe7 Kb6 17. Qe8f7`,
+			shouldFail:  false,
+			description: "Complex game without full square disambiguation (should work)",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			reader := strings.NewReader(tc.pgn)
+			scanner := NewScanner(reader)
+
+			game, err := scanner.ParseNext()
+			if err != nil {
+				if !tc.shouldFail {
+					t.Errorf("Expected PGN parsing to succeed but got error: %v", err)
+				}
+				// If we expected it to fail, verify it's the right kind of error
+				if tc.shouldFail && !strings.Contains(err.Error(), "invalid destination square") {
+					t.Logf("Expected 'invalid destination square' error but got: %v", err)
+				}
+				return
+			}
+
+			if tc.shouldFail {
+				t.Errorf("Expected test case '%s' to fail but it succeeded. Description: %s", tc.name, tc.description)
+			}
+
+			// Additional validation for successful cases
+			if !tc.shouldFail {
+				if game == nil {
+					t.Errorf("Game should not be nil for successful parsing")
+				}
+			}
+		})
+	}
+}
+
+// TestTokenizerDisambiguationSquares tests that the lexer correctly tokenizes disambiguation squares
+func TestTokenizerDisambiguationSquares(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected []TokenType
+	}{
+		{
+			name:     "queen_with_full_square_disambiguation",
+			input:    "Qe8f7",
+			expected: []TokenType{PIECE, DeambiguationSquare, SQUARE},
+		},
+		{
+			name:     "rook_with_full_square_disambiguation",
+			input:    "Ra1d1",
+			expected: []TokenType{PIECE, DeambiguationSquare, SQUARE},
+		},
+		{
+			name:     "knight_with_full_square_disambiguation",
+			input:    "Nb1c3",
+			expected: []TokenType{PIECE, DeambiguationSquare, SQUARE},
+		},
+		{
+			name:     "standard_piece_move",
+			input:    "Nf3",
+			expected: []TokenType{PIECE, SQUARE},
+		},
+		{
+			name:     "piece_with_file_disambiguation",
+			input:    "Nbd2",
+			expected: []TokenType{PIECE, FILE, SQUARE},
+		},
+		{
+			name:     "piece_with_rank_disambiguation",
+			input:    "R1d2",
+			expected: []TokenType{PIECE, RANK, SQUARE},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			lexer := NewLexer(tc.input)
+			var actualTypes []TokenType
+
+			for {
+				token := lexer.NextToken()
+				if token.Type == EOF {
+					break
+				}
+				actualTypes = append(actualTypes, token.Type)
+				t.Logf("Token: %s, Value: %s", token.Type, token.Value)
+			}
+
+			if len(actualTypes) != len(tc.expected) {
+				t.Errorf("Expected %d tokens, got %d", len(tc.expected), len(actualTypes))
+				t.Errorf("Expected: %v", tc.expected)
+				t.Errorf("Actual: %v", actualTypes)
+				return
+			}
+
+			for i, expected := range tc.expected {
+				if actualTypes[i] != expected {
+					t.Errorf("Token %d: expected %s, got %s", i, expected, actualTypes[i])
+				}
+			}
+		})
+	}
+}