// Play asks for input from an external source until a valid move is given.
func (human *HumanAgent) Play(
	referee *mancala.Referee,
	player mancala.PlayerIndex,
) (mancala.HouseIndex, error) {
	move := mancala.HouseIndex(-1)
	var moveLine string
	for move == -1 {
		fmt.Printf("%s, make a move:\n", strings.Title(player.String()))
		fmt.Scanf("%s", &moveLine)
		fmt.Println()
		parsedMove, err := strconv.Atoi(moveLine)
		if err != nil {
			fmt.Println("Input must be an integer.")
			fmt.Println()
			moveLine = ""
		} else if _, err := referee.SimulateMove(
			player,
			mancala.HouseIndex(parsedMove),
		); err != nil {
			fmt.Printf("Illegal move: %v.\n", err)
			fmt.Println()
			moveLine = ""
			move = -1
		} else {
			move = mancala.HouseIndex(parsedMove)
		}
	}
	return move, nil
}

// testCaptureLoop is a simulateTestCaseGenerator which generates a test case
// where the current mancala.Player captures after looping around the
// mancala.Board.
func testCaptureLoop(player mancala.PlayerIndex) simulateTestCase {
	grid := mancala.Grid{}
	grid[player] = mancala.Row{17, 0, 0, 0, 0, 0}
	grid[player.Other()] = mancala.Row{}
	board := mancala.NewInitializedBoard(0, 0, grid)
	expectedGrid := mancala.Grid{}
	expectedGrid[player] = mancala.Row{0, 2, 2, 2, 2, 2}
	expectedGrid[player.Other()] = mancala.Row{0, 1, 1, 1, 1, 1}
	player1Score := 0
	player2Score := 0
	if player == mancala.Player1 {
		player1Score += 2
	} else {
		player2Score += 2
	}
	expectedBoard := mancala.NewInitializedBoard(
		player1Score, player2Score,
		expectedGrid,
	)
	return simulateTestCase{
		referee: mancala.NewInitializedReferee(
			[]mancala.Board{},
			board,
		),
		move:          0,
		expectedBoard: expectedBoard,
		expectedErr:   nil,
	}
}

// testAlreadySeenBoard is a simulateTestCaseGenerator which generates a test
// case where the current mancala.Board is in the mancala.Referee's
// mancala.Board history.
func testAlreadySeenBoard(player mancala.PlayerIndex) simulateTestCase {
	seenGrid := mancala.Grid{}
	seenGrid[player] = mancala.Row{0, 1, 1, 1, 1, 1}
	seenGrid[player.Other()] = mancala.Row{1, 0, 0, 0, 0, 0}
	grid := mancala.Grid{}
	grid[player] = mancala.Row{5, 0, 0, 0, 0, 0}
	grid[player.Other()] = mancala.Row{1, 0, 0, 0, 0, 0}
	referee := mancala.NewInitializedReferee(
		[]mancala.Board{mancala.NewInitializedBoard(0, 0, seenGrid)},
		mancala.NewInitializedBoard(0, 0, grid),
	)
	player1Score := 0
	player2Score := 0
	if player == mancala.Player1 {
		player1Score += 5
		player2Score++
	} else {
		player2Score += 5
		player1Score++
	}
	expectedBoard := mancala.NewInitializedBoard(
		player1Score, player2Score,
		mancala.Grid{},
	)
	return simulateTestCase{
		referee:       referee,
		move:          0,
		expectedBoard: expectedBoard,
		expectedErr:   nil,
	}
}

// NewRootState creates the root State of a mancala game search tree with a
// mancala.Referee and mancala.PlayerIndex.
func NewRootState(
	referee *mancala.Referee,
	index mancala.PlayerIndex,
) *State {
	return &State{
		parent:      nil,
		referee:     referee,
		information: NewInformation(referee.Board(), index.Other(), -1),
	}
}

// ProtectValueChecker is a ValueChecker which returns the number of seeds the
// opponent can capture after a move multipled by -1, showing that moves which
// let opponent's capture more seeds are unfavorable.
func ProtectValueChecker(state *State, index mancala.PlayerIndex) int {
	var max int
	first := true
	for _, child := range state.ReachableStates() {
		captured := CaptureValueChecker(child, index.Other())
		if first || captured > max {
			max = captured
			first = false
		}
	}
	return -max
}

// testCaptureAllHouses is a simulateTestCaseGenerator which generates a test
// case where the current mancala.Player captures all of the other
// mancala.Player's houses from the end of the other mancala.Player's row to the
// beginning.
func testCaptureAllHouses(player mancala.PlayerIndex) simulateTestCase {
	grid := mancala.Grid{}
	grid[player] = mancala.Row{0, 0, 0, 0, 0, 6}
	grid[player.Other()] = mancala.Row{1, 1, 1, 1, 1, 1}
	board := mancala.NewInitializedBoard(0, 0, grid)
	expectedGrid := mancala.Grid{}
	expectedGrid[player] = mancala.Row{}
	expectedGrid[player.Other()] = mancala.Row{2, 2, 2, 2, 2, 2}
	expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid)
	return simulateTestCase{
		referee: mancala.NewInitializedReferee(
			[]mancala.Board{}, board,
		),
		move:          5,
		expectedBoard: expectedBoard,
		expectedErr:   nil,
	}
}

// testSowLoopToStart is a simulateTestCaseGenerator which generates a test case
// where the current mancala.Player sows in a loop around the mancala.Board just
// past the house the mancala.Player started sowing from.
func testSowLoopToStart(player mancala.PlayerIndex) simulateTestCase {
	grid := mancala.Grid{}
	grid[player] = mancala.Row{0, 0, 0, 0, 0, 45}
	grid[player.Other()] = mancala.Row{}
	board := mancala.NewInitializedBoard(0, 0, grid)
	expectedGrid := mancala.Grid{}
	expectedGrid[player] = mancala.Row{4, 4, 4, 4, 4, 0}
	expectedGrid[player.Other()] = mancala.Row{5, 4, 4, 4, 4, 4}
	expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid)
	return simulateTestCase{
		referee: mancala.NewInitializedReferee(
			[]mancala.Board{}, board,
		),
		move:          5,
		expectedBoard: expectedBoard,
		expectedErr:   nil,
	}
}

// testSowToOtherSide is a simulateTestCaseGenerator which generates a test case
// where the current mancala.Player sows to the middle of the other
// mancala.Player's mancala.Row.
func testSowToOtherSide(player mancala.PlayerIndex) simulateTestCase {
	grid := mancala.Grid{}
	grid[player] = mancala.Row{0, 0, 6, 0, 0, 0}
	grid[player.Other()] = mancala.Row{}
	board := mancala.NewInitializedBoard(0, 0, grid)
	expectedGrid := mancala.Grid{}
	expectedGrid[player] = mancala.Row{0, 0, 0, 1, 1, 1}
	expectedGrid[player.Other()] = mancala.Row{1, 1, 1, 0, 0, 0}
	expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid)
	return simulateTestCase{
		referee: mancala.NewInitializedReferee(
			[]mancala.Board{}, board,
		),
		move:          2,
		expectedBoard: expectedBoard,
		expectedErr:   nil,
	}
}

// testNoSeeds is a simulateTestCaseGenerator which generates a test case where
// the other mancala.Player has no seeds and the current mancala.Player has a
// move which will give the other mancala.Player seeds and doesn't make it.
func testNoSeedsCanReach(player mancala.PlayerIndex) simulateTestCase {
	grid := mancala.Grid{}
	grid[player] = mancala.Row{1, 0, 0, 0, 0, 1}
	board := mancala.NewInitializedBoard(0, 0, grid)
	return simulateTestCase{
		referee: mancala.NewInitializedReferee(
			[]mancala.Board{}, board,
		),
		move:          0,
		expectedBoard: board,
		expectedErr: fmt.Errorf(
			"moves exist which can give %v seeds but move at %d "+
				"doesn't",
			player.Other(),
			0,
		),
	}
}