import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.junit.Test;

public class SudokuSolverTest {

  @Test
  public void isOneThroughNine_matches() {
    List<Integer> baseCase = new ArrayList<>();
    for (int i = 1; i < 10; i++) {
      baseCase.add(i);
    }
    assertTrue(SudokuSolver.isOneThroughNine(baseCase));
  }

  @Test
  public void isOneThroughNine_unsortedMatches() {
    List<Integer> baseCase = new ArrayList<>();
    for (int i = 9; i > 0; i--) {
      baseCase.add(i);
    }
    assertTrue(SudokuSolver.isOneThroughNine(baseCase));
  }

  @Test
  public void isOneThroughNine_missingFirst() {
    List<Integer> baseCase = new ArrayList<>();
    for (int i = 1; i < 9; i++) {
      baseCase.add(i);
    }
    assertFalse(SudokuSolver.isOneThroughNine(baseCase));
  }

  @Test
  public void isOneThroughNine_missingLast() {
    List<Integer> baseCase = new ArrayList<>();
    for (int i = 2; i < 10; i++) {
      baseCase.add(i);
    }
    assertFalse(SudokuSolver.isOneThroughNine(baseCase));
  }

  @Test
  public void isOneThroughNine_offset() {
    List<Integer> baseCase = new ArrayList<>();
    for (int i = 2; i < 11; i++) {
      baseCase.add(i);
    }
    assertFalse(SudokuSolver.isOneThroughNine(baseCase));
  }

  @Test
  public void isOneThroughNine_tooShort() {
    assertFalse(SudokuSolver.isOneThroughNine(Collections.emptyList()));
  }

  @Test
  public void isOneThroughNine_tooLong() {
    assertFalse(SudokuSolver.isOneThroughNine(Collections.nCopies(1, 1)));
  }

  @Test
  public void isValidChoice_valid() {
    assertTrue(SudokuSolver.isValidChoice(1, Collections.emptyList()));
    assertFalse(SudokuSolver.isValidChoice(1, Collections.singletonList(1)));
    assertFalse(SudokuSolver.isValidChoice(0, Collections.emptyList()));
  }

  @Test
  public void validSudoku_valid() {
    int[][] input = {
        {5, 3, 4, 6, 7, 8, 9, 1, 2},
        {6, 7, 2, 1, 9, 5, 3, 4, 8},
        {1, 9, 8, 3, 4, 2, 5, 6, 7},
        {8, 5, 9, 7, 6, 1, 4, 2, 3},
        {4, 2, 6, 8, 5, 3, 7, 9, 1},
        {7, 1, 3, 9, 2, 4, 8, 5, 6},
        {9, 6, 1, 5, 3, 7, 2, 8, 4},
        {2, 8, 7, 4, 1, 9, 6, 3, 5},
        {3, 4, 5, 2, 8, 6, 1, 7, 9}
    };

    assertTrue(SudokuSolver.validSudoku(input));

  }

  @Test
  public void validSudoku_invalid() {
    int[][] input = {
        {1, 3, 4, 6, 7, 8, 9, 1, 2},
        {6, 7, 2, 1, 9, 5, 3, 4, 8},
        {1, 9, 8, 3, 4, 2, 5, 6, 7},
        {8, 5, 9, 7, 6, 1, 4, 2, 3},
        {4, 2, 6, 8, 5, 3, 7, 9, 1},
        {7, 1, 3, 9, 2, 4, 8, 5, 6},
        {9, 6, 1, 5, 3, 7, 2, 8, 4},
        {2, 8, 7, 4, 1, 9, 6, 3, 5},
        {3, 4, 5, 2, 8, 6, 1, 7, 9}
    };

    assertFalse(SudokuSolver.validSudoku(input));

  }

}