import java.util.Random;
/**
 *
 *    Mastermind.java
 *
 *    Implements the game Mastermind.
 *
 *    @version      1.0   Feb 15, 197
 *    @author       Kwok-Bun Yue
 *    @see          http://ricis.cl.uh.edu/~yue/s97/4931/index.html
 *
 *    Colors are defined as positive int: 1, 2, 3, 4, ...
 *
 *    Because of space, this is not a clean design.
 *    A better design is based on the MVC (Model-View-Controller)
 *    pattern where the model (the application) contains methods
 *    of the Mastermind game.  The view includes GUI methods and
 *    the controller controls the interaction between the model 
 *    and the view.  
 *
 *    In the current design, the Mastermind class contains methods
 *    such as printHistory() that belongs to the view in the
 *    MVC pattern.  Because of the simplicity of the class, the
 *    current design is simpler and quicker.
 *
 **/

class Mastermind {
    //  constants
    public final static int STANDARD_NUM_OF_SLOTS  = 4;
    public final static int STANDARD_NUM_OF_COLORS = 6;
    public final static int STANDARD_MAX_GUESSES   = 30;

    //  random number generator to generate solutions.
    private static Random RANDOM = new Random();

    //  private data members: ends with _.
    private int[][] guesses_;        //  history of guesses.
    private int[][] hints_;          //  history of hints.
    private int[] answer_;           //  answer of the game.
    private int currentGuess_;       //  current guess to make.

    private int numSlots_;           //  number of slots used.
    private int numColors_;          //  number of colors used.
    private int maxGuesses_;         //  max number of guesses.

    private boolean gameOver_;       //  true iff game is over.
    private boolean gameWon_;        //  true iff player guesses right.

    //  constructors.
    public Mastermind() {
        this(STANDARD_NUM_OF_SLOTS,
             STANDARD_NUM_OF_COLORS,
             STANDARD_MAX_GUESSES);
    }

    public Mastermind(int maxGuesses) {
        this(STANDARD_NUM_OF_SLOTS,
             STANDARD_NUM_OF_COLORS,
             maxGuesses);
    }

    public Mastermind(int numSlots, int numColors) {
        this(numSlots, numColors, STANDARD_MAX_GUESSES);
    }

    public Mastermind(int numSlots, int numColors, int maxGuesses) {
        numSlots_ = numSlots;
        numColors_ = numColors;
        maxGuesses_ = maxGuesses;
        newGame();
    }

    //  public methods

    //  Create a new game.
    public void newGame() {
        //  initialize instant variables.
        currentGuess_ = 0;
        gameOver_ = false;
        gameWon_ = false;

        //  allocate arrays.
        guesses_ = new int[maxGuesses_] [numSlots_];
        hints_ = new int[maxGuesses_] [2];    //  [0]: ox; [1]: cow.
        answer_ = new int[numSlots_];

        //  set the answer (solution).
		//  each slot gets an integer from 1 to numColors_
        for (int i=0; i<numSlots_; i++)
            answer_[i] = (Math.abs(RANDOM.nextInt()) % numColors_) + 1;
        //  print out solution.
        //     for (int i=0; i<numSlots_; i++)
        //        System.out.println(answer_[i]);

    }

    //   Player makes a guess.
    public boolean makeGuess(int[] guess, int[] hint) {
        if (gameOver_) return false;
		
		// copy the current guess to the guesses_ 2d array
        System.arraycopy(guess, 0, guesses_[currentGuess_], 0, numSlots_);

        setHints(answer_, guess, hint);

        //  Store hint into the hint history: hints_
        hints_[currentGuess_][0] = hint[0];
        hints_[currentGuess_][1] = hint[1];
        currentGuess_++;

        //  update gameWon_ and gameOver_
        if (hint[0] == numSlots_) {
            gameWon_ = true;
            gameOver_ = true;
        }

        if (currentGuess_ >= maxGuesses_) {
            gameWon_ = false;
            gameOver_ = true;
        }
        return true;
    }

   //  Check whether game is won.
   public boolean gameWon() { return gameWon_; }

   //  Check whether game is over.
   public boolean gameOver() { return gameOver_; }

   //  Print the history of the guesses and hints.
   public void printHistory() {
       System.out.print("guess#\t");
       for (int i=0; i<numSlots_; i++)
           System.out.print("s"+(i+1)+"\t");
       System.out.println("ox #\tcow #");
       System.out.println("----------------------------------------------------------");
       for (int i=0; i<currentGuess_; i++) {
           System.out.print((i+1)+"\t");
           for (int j=0; j<numSlots_; j++)
               System.out.print(guesses_[i][j]+"\t");
           System.out.print(hints_[i][0] + "\t");
           System.out.println(hints_[i][1] + "\t");
       }
       System.out.println("\t");
   }

   //  private methods:
   private void setHints(int[] solution, int[] guess, int[] hint) {
       //  compute hints: not very efficient.
       int length = solution.length;
       int numOx = 0;
       int numCow = 0;
       int[] tempSol = new int[length];
       System.arraycopy(solution, 0, tempSol, 0, length);
       int[] tempGuess = new int[length];
       System.arraycopy(guess, 0, tempGuess, 0, length);
   //  loop from  to numSlots_ - 1
   //  Find the number of ox.
       for (int i=0; i<numSlots_; i++) {
           if (tempSol[i] == tempGuess[i]) {
               numOx++;
               tempSol[i] = -1;
               tempGuess[i] = -1;
           }
       }
	   
	   // Find the number of cow.
	   //  loop from  to numSlots_ - 1
       for (int i=0; i<numSlots_; i++) {
           if (tempGuess[i] >= 0) {
               for (int j=0; j<numSlots_; j++) {
                   if (tempGuess[i] == tempSol[j]) {
                       numCow++;
                       tempSol[j] = -1;
                       break;
                   }
               }
           }
       }
       hint[0] = numOx;
       hint[1] = numCow;
   }
}