/*
 * WordGuess.java
 * The Word Guess Game
 * To compile: javac -classpath twoplayer.jar:.  WordGuess.java
 * To run CLUI:  java -classpath twoplayer.jar:. WordGuess
 */

public class WordGuess extends TwoPlayerGame implements CLUIPlayableGame {
    private String secretWord;
    private StringBuffer currentWord;
    private StringBuffer previousGuesses;
    private int unguessedLetters;

    public WordGuess() {   
        secretWord = getSecretWord();
        currentWord = new StringBuffer(secretWord);
        previousGuesses = new StringBuffer();
        for (int k = 0; k < secretWord.length(); k++)
           currentWord.setCharAt(k,'?');
        unguessedLetters = secretWord.length();
    } //WordGuess() constructor

    public String getPreviousGuesses() {
	return previousGuesses.toString();
    }
    public String getCurrentWord() {
	return currentWord.toString();
    }
    private String getSecretWord() {   
        int num = (int)(Math.random()*10);
        switch (num)
        {   case 0: return "SOFTWARE";
            case 1: return "SOLUTION";
            case 2: return "CONSTANT";
            case 3: return "COMPILER";
            case 4: return "ABSTRACT";
            case 5: return "ABNORMAL";
            case 6: return "ARGUMENT";
            case 7: return "QUESTION";
            case 8: return "UTILIZES";
            case 9: return "VARIABLE";
            default: return "MISTAKES";
        } //switch
    } //getSecretWord()

    /* Returns true if letter is a new correct letter
    in which case the letter is filled into currentWord.
    */
    private boolean guessLetter(char letter) {   
	previousGuesses.append(letter);
	if (secretWord.indexOf(letter) == -1)
            return false; // letter is not in secretWord
        else // find positions of letter in secretWord
        {   for (int k = 0; k < secretWord.length(); k++)
            {   if (secretWord.charAt(k) == letter)
                {   if (currentWord.charAt(k) == letter)
                        return false; //already guessed
                    currentWord.setCharAt(k,letter);
                    unguessedLetters--; //one less to find
                } //if
            } //for
            return true;
        } //else
    } //guessLetter()

    /** Overridden method from TwoPlayerGame */
    public String getRules() {   
        return "\n*** The Rules of Word Guess ***\n" +
        "(1) The game generates a secret word.\n" +
        "(2) Two players alternate taking moves.\n" +
        "(3) A move consists of guessing a letter in the word.\n" +
        "(4) A player continues guessing until a letter is wrong.\n" +
        "(5) The game is over when all letters of the word are guessed\n" +
        "(6) The player guessing the last letter of the word wins.\n";
    } //getRules()

    /** Implementation of abstract method from TwoPlayerGame */
    public boolean gameOver() {   
        return (unguessedLetters <= 0);
    } // gameOver()

    /** Implementation of abstract method from TwoPlayerGame */
    public String getWinner() {   
        if (gameOver())
            return "Player " + getPlayer();
        else return "The game is not over.";
    } // getWinner()

    /**********
    public void createComputerPlayers(int nComputers) {
	if (nComputers == 1) {
            computer2 = new WordGuesser(this);
	} else if (nComputers == 2) {
            computer1 = new WordGuesser(this);
            computer2 = new WordGuesser(this);
	}
    }
    ***********/
        /** From Playable interface */
    public void play(UserInterface ui) {
        ui.report(getRules());
        if (computer1 != null) 
            ui.report("\nPlayer 1 is a " + computer1.toString());
	if (computer2 != null)
	    ui.report("\nPlayer 2 is a " + computer2.toString());

	while(!gameOver()) {  
           IPlayer computer = null;       // Assume no computers playing
	    ui.report(reportGameState());
            switch(getPlayer()) {
	    case PLAYER_ONE:             // Player 1's turn
		computer = computer1;
		break;
	    case PLAYER_TWO:             // Player 2's turn
		computer = computer2;
		break;
	    } // cases

            if (computer != null) {      // If computer's turn
		ui.report(submitUserMove(computer.makeAMove("")));
	    } else {                     // otherwise, user's turn
		ui.prompt(getGamePrompt());
                ui.report(submitUserMove(ui.getUserInput()));
	    }
        } // while
	ui.report(reportGameState());  // The game is now over
    }

    /** Implementation of method from CLUIPlayable */
    public String reportGameState() {   
	if (!gameOver())
	    return "\nCurrent word " + currentWord.toString() + " Previous guesses " 
		+ previousGuesses + "\nPlayer " + getPlayer() + " guesses next.";
	else 
	    return "\nThe game is now over! The secret word is " + secretWord +
		"\n" + getWinner() + " has won!\n";
    } // report()

    /** Implementation of method from CLUIPlayable */
    public String getGamePrompt()
    {    return "\nGuess a letter that you think is in the secret word: ";
    } //prompt()

    /** Implementation of method from CLUIPlayable */
    public String submitUserMove(String s) {   
        char letter = s.toUpperCase().charAt(0);
        if (guessLetter(letter)) {   //if correct 
            return "Yes, the letter " + letter +
                   " IS in the secret word\n";
         } else {   
             changePlayer();
             return "Sorry, " + letter + " is NOT a " +
                    "new letter in the secret word\n";
         } 
    } //move()

    /*** A WordGuess Application Program
    */
    public static void main(String args[])  {  
	KeyboardReader kb = new KeyboardReader();
        WordGuess game = new WordGuess();
        kb.prompt("How many computers are playing, 0, 1, or 2? ");
	int m = kb.getKeyboardInteger();
        for (int k = 0; k < m; k++) {
            IPlayer computer = new WordGuessExpert(game);
	    //            IPlayer computer = new WordGuesst(game);
            game.addComputerPlayer(computer);
	}
	//        game.setNComputers(m);
        game.play(kb);
    } //main()
    
} //WordGuess class