package engine

import "testing"

// TestResignLeadingPlayerStillLoses is the core of the resignation fix: a player
// who resigns loses even when leading on score, the remaining player wins, and
// the resigner's score is frozen (no end-game rack adjustment).
func TestResignLeadingPlayerStillLoses(t *testing.T) {
	g := openingGame(t)

	hint, ok := g.HintView()
	if !ok {
		t.Fatal("opening game has no hint")
	}
	played, err := g.SubmitPlay(hint.Dir, hint.Tiles)
	if err != nil {
		t.Fatalf("player 0 play: %v", err)
	}
	if played.Score == 0 {
		t.Fatal("opening play scored 0; pick a different seed")
	}

	if _, err := g.Pass(); err != nil { // player 1
		t.Fatalf("player 1 pass: %v", err)
	}

	// Player 0 is now on turn and leads 0:played.Score; resigning must still lose.
	if _, err := g.Resign(); err != nil {
		t.Fatalf("player 0 resign: %v", err)
	}

	if !g.Over() || g.Reason() != EndResign {
		t.Fatalf("game over=%v reason=%v, want over with resign", g.Over(), g.Reason())
	}
	res := g.Result()
	if res.Winner != 1 {
		t.Errorf("winner = %d, want 1 (the non-resigner) despite the resigner leading", res.Winner)
	}
	if g.Score(0) != played.Score {
		t.Errorf("resigner score = %d, want frozen at %d (no rack adjustment)", g.Score(0), played.Score)
	}
	if g.Score(1) != 0 {
		t.Errorf("opponent score = %d, want 0", g.Score(1))
	}
	if g.Score(0) <= g.Score(1) {
		t.Fatal("test precondition: resigner should lead on raw score")
	}
}

// TestResignTrailingPlayerLoses covers the ordinary case: the trailing player
// resigns and the leader wins.
func TestResignTrailingPlayerLoses(t *testing.T) {
	g := openingGame(t)

	hint, ok := g.HintView()
	if !ok {
		t.Fatal("opening game has no hint")
	}
	if _, err := g.SubmitPlay(hint.Dir, hint.Tiles); err != nil { // player 0 scores
		t.Fatalf("player 0 play: %v", err)
	}

	// Player 1 (trailing 0 points) resigns.
	if _, err := g.Resign(); err != nil {
		t.Fatalf("player 1 resign: %v", err)
	}
	if res := g.Result(); res.Winner != 0 {
		t.Errorf("winner = %d, want 0", res.Winner)
	}
}

// TestResignOnFinishedGame rejects a second transition.
func TestResignOnFinishedGame(t *testing.T) {
	g := newEnglishGame(t, 1)
	if _, err := g.Resign(); err != nil {
		t.Fatalf("first resign: %v", err)
	}
	if _, err := g.Resign(); err == nil {
		t.Error("resign on a finished game must error")
	}
}