import java.util.HashSet;
import java.util.Scanner;

/**
 * Game of Bombardment
 *
 * Based on the Basic game of Bombardment here
 * https://github.com/coding-horror/basic-computer-games/blob/main/11%20Bombardment/bombardment.bas
 *
 * Note:  The idea was to create a version of this 1970's Basic game in Java, without introducing
 *        new features - no additional text, error checking, etc has been added.
 */
public class Bombardment {

    public static final int MAX_GRID_SIZE = 25;
    public static final int PLATOONS = 4;

    private enum GAME_STATE {
        STARTING,
        DRAW_BATTLEFIELD,
        GET_PLAYER_CHOICES,
        PLAYERS_TURN,
        COMPUTER_TURN,
        PLAYER_WON,
        PLAYER_LOST,
        GAME_OVER
    }

    private GAME_STATE gameState;

    public static final String[] PLAYER_HIT_MESSAGES = { "ONE DOWN, THREE TO GO.",
            "TWO DOWN, TWO TO GO.", "THREE DOWN, ONE TO GO." };

    public static final String[] COMPUTER_HIT_MESSAGES = {"YOU HAVE ONLY THREE OUTPOSTS LEFT.",
            "YOU HAVE ONLY TWO OUTPOSTS LEFT.", "YOU HAVE ONLY ONE OUTPOST LEFT." };

    private HashSet<Integer> computersPlatoons;
    private HashSet<Integer> playersPlatoons;

    private HashSet<Integer> computersGuesses;

    // Used for keyboard input
    private final Scanner kbScanner;

    public Bombardment() {

        this.gameState = GAME_STATE.STARTING;

        // Initialise kb scanner
        kbScanner = new Scanner(System.in);
    }

    /**
     * Main game loop
     */
    public void play() {

        do {
            switch (this.gameState) {

                // Show an introduction the first time the game is played.
                case STARTING:
                    init();
                    intro();
                    this.gameState = GAME_STATE.DRAW_BATTLEFIELD;
                    break;

                // Enter the players name
                case DRAW_BATTLEFIELD:
                    drawBattlefield();
                    this.gameState = GAME_STATE.GET_PLAYER_CHOICES;
                    break;

                // Get the players 4 locations for their platoons
                case GET_PLAYER_CHOICES:
                    String playerChoices = displayTextAndGetInput("WHAT ARE YOUR FOUR POSITIONS? ");

                    // Store the 4 player choices that were entered separated with commas
                    for(int i=0; i<PLATOONS; i++) {
                        playersPlatoons.add(getDelimitedValue(playerChoices,i));
                    }

                    this.gameState = GAME_STATE.PLAYERS_TURN;
                    break;

                // Players turn to pick a location
                case PLAYERS_TURN:

                    int firePosition = getDelimitedValue(
                            displayTextAndGetInput("WHERE DO YOU WISH TO FIRE YOUR MISSILE? "),0);

                    if(didPlayerHitComputerPlatoon(firePosition)) {
                        // Player hit a player platoon
                        int hits = updatePlayerHits(firePosition);
                        // How many hits has the player made?
                        if(hits != PLATOONS) {
                            showPlayerProgress(hits);
                            this.gameState = GAME_STATE.COMPUTER_TURN;
                        } else {
                            // Player has obtained 4 hits, they win
                            this.gameState = GAME_STATE.PLAYER_WON;
                        }
                    } else {
                        // Player missed
                        System.out.println("HA, HA YOU MISSED. MY TURN NOW:");
                        System.out.println();
                        this.gameState = GAME_STATE.COMPUTER_TURN;
                    }

                    break;

                // Computers time to guess a location
                case COMPUTER_TURN:

                    // Computer takes a guess of a location
                    int computerFirePosition = uniqueComputerGuess();
                    if(didComputerHitPlayerPlatoon(computerFirePosition)) {
                        // Computer hit a player platoon
                        int hits = updateComputerHits(computerFirePosition);
                        // How many hits has the computer made?
                        if(hits != PLATOONS) {
                            showComputerProgress(hits, computerFirePosition);
                            this.gameState = GAME_STATE.PLAYERS_TURN;
                        } else {
                            // Computer has obtained 4 hits, they win
                            System.out.println("YOU'RE DEAD. YOUR LAST OUTPOST WAS AT " + computerFirePosition
                                    + ". HA, HA, HA.");
                            this.gameState = GAME_STATE.PLAYER_LOST;
                        }
                    } else {
                        // Computer missed
                        System.out.println("I MISSED YOU, YOU DIRTY RAT. I PICKED " + computerFirePosition
                                + ". YOUR TURN:");
                        System.out.println();
                        this.gameState = GAME_STATE.PLAYERS_TURN;
                    }

                    break;

                // The player won
                case PLAYER_WON:
                    System.out.println("YOU GOT ME, I'M GOING FAST. BUT I'LL GET YOU WHEN");
                    System.out.println("MY TRANSISTO&S RECUP%RA*E!");
                    this.gameState = GAME_STATE.GAME_OVER;
                    break;

                case PLAYER_LOST:
                    System.out.println("BETTER LUCK NEXT TIME.");
                    this.gameState = GAME_STATE.GAME_OVER;
                    break;

                // GAME_OVER State does not specifically have a case
            }
        } while (this.gameState != GAME_STATE.GAME_OVER);
    }

    /**
     * Calculate computer guess.  Make that the computer does not guess the same
     * location twice
     *
     * @return  location of the computers guess that has not been guessed previously
     */
    private int uniqueComputerGuess() {

        boolean validGuess = false;
        int computerGuess;
        do
        {
            computerGuess = randomNumber();

            if(!computersGuesses.contains(computerGuess)) {
                validGuess = true;
            }
        } while(!validGuess);

        computersGuesses.add(computerGuess);

        return computerGuess;
    }

    /**
     * Create four unique platoons locations for the computer
     * We are using a hashset which guarantees uniqueness so
     * all we need to do is keep trying to add a random number
     * until all four are in the hashset
     *
     * @return 4 locations of computers platoons
     *
     */
    private HashSet<Integer> computersChosenPlatoons() {

        // Initialise contents
        HashSet<Integer> tempPlatoons = new HashSet<>();

        boolean allPlatoonsAdded = false;

        do {
            tempPlatoons.add(randomNumber());

            // All four created?
            if(tempPlatoons.size() == PLATOONS) {
                // Exit when we have created four
                allPlatoonsAdded = true;
            }

        } while(!allPlatoonsAdded);

        return tempPlatoons;
    }
    /**
     * Shows a different message for each number of hits
     *
     * @param hits  total number of hits by player on computer
     */
    private void showPlayerProgress(int hits) {

        System.out.println("YOU GOT ONE OF MY OUTPOSTS!");
        showProgress(hits, PLAYER_HIT_MESSAGES);
    }

    /**
     * Shows a different message for each number of hits
     *
     * @param hits  total number of hits by computer on player
     */
    private void showComputerProgress(int hits, int lastGuess) {

        System.out.println("I GOT YOU. IT WON'T BE LONG NOW. POST " + lastGuess + " WAS HIT.");
        showProgress(hits, COMPUTER_HIT_MESSAGES);
    }

    /**
     * Prints a message from the passed array based on the value of hits

     * @param hits - number of hits the player or computer has made
     * @param messages - an array of string with messages
     */
    private void showProgress(int hits, String[] messages) {
        System.out.println(messages[hits-1]);
    }

    /**
     *
     * Update a player hit - adds a hit the player made on the computers platoon.
     * @param fireLocation - computer location that got hit
     * @return number of hits the player has inflicted on the computer in total
     */
    private int updatePlayerHits(int fireLocation) {

        // N.B. only removes if present, so its redundant to check if it exists first
        this.computersPlatoons.remove(fireLocation);

        // return number of hits in total
        return PLATOONS - this.computersPlatoons.size();
    }

    /**
     *
     * Update a computer hit - adds a hit the computer made on the players platoon.
     * @param fireLocation - player location that got hit
     * @return number of hits the player has inflicted on the computer in total
     */
    private int updateComputerHits(int fireLocation) {

        // N.B. only removes if present, so its redundant to check if it exists first
        this.playersPlatoons.remove(fireLocation);

        // return number of hits in total
        return PLATOONS - this.playersPlatoons.size();
    }

    /**
     * Determine if the player hit one of the computers platoons
     *
     * @param fireLocation the players choice of location to fire on
     * @return true if a computer platoon was at that position
     */
    private boolean didPlayerHitComputerPlatoon(int fireLocation) {
        return this.computersPlatoons.contains(fireLocation);
    }

    /**
     * Determine if the computer hit one of the players platoons
     *
     * @param fireLocation the computers choice of location to fire on
     * @return true if a players platoon was at that position
     */
    private boolean didComputerHitPlayerPlatoon(int fireLocation) {
        return this.playersPlatoons.contains(fireLocation);
    }

    /**
     * Draw the battlefield grid
     *
     */
    private void drawBattlefield() {
        for(int i=1; i<MAX_GRID_SIZE+1; i+= 5) {
            System.out.printf("%-2s %-2s %-2s %-2s %-2s %n", i, i+1, i+2, i+3, i+4);
        }
    }

    /**
     * Basic information about the game
     *
     */
    private void intro() {
        System.out.println("BOMBARDMENT");
        System.out.println("CREATIVE COMPUTING  MORRISTOWN, NEW JERSEY");
        System.out.println();
        System.out.println("YOU ARE ON A BATTLEFIELD WITH 4 PLATOONS AND YOU");
        System.out.println("HAVE 25 OUTPOSTS AVAILABLE WHERE THEY MAY BE PLACED.");
        System.out.println("YOU CAN ONLY PLACE ONE PLATOON AT ANY ONE OUTPOST.");
        System.out.println("THE COMPUTER DOES THE SAME WITH ITS FOUR PLATOONS.");
        System.out.println();
        System.out.println("THE OBJECT OF THE GAME IS TO FIRE MISSILES AT THE");
        System.out.println("OUTPOSTS OF THE COMPUTER.  IT WILL DO THE SAME TO YOU.");
        System.out.println("THE ONE WHO DESTROYS ALL FOUR OF THE ENEMY'S PLATOONS");
        System.out.println("FIRST IS THE WINNER.");
        System.out.println();
        System.out.println("GOOD LUCK... AND TELL US WHERE YOU WANT THE BODIES SENT!");
        System.out.println();
        System.out.println("TEAR OFF MATRIX AND USE IT TO CHECK OFF THE NUMBERS.");
        System.out.println();
        System.out.println();
    }

    private void init() {

        // Create four locations for the computers platoons.
        this.computersPlatoons = computersChosenPlatoons();

        // Players platoons.
        this.playersPlatoons = new HashSet<>();

        this.computersGuesses = new HashSet<>();
    }

    /**
     * Accepts a string delimited by comma's and returns the nth delimited
     * value (starting at count 0).
     *
     * @param text - text with values separated by comma's
     * @param pos  - which position to return a value for
     * @return the int representation of the value
     */
    private int getDelimitedValue(String text, int pos) {
        String[] tokens = text.split(",");
        return Integer.parseInt(tokens[pos]);
    }


    /*
     * Print a message on the screen, then accept input from Keyboard.
     *
     * @param text message to be displayed on screen.
     * @return what was typed by the player.
     */
    private String displayTextAndGetInput(String text) {
        System.out.print(text);
        return kbScanner.next();
    }

    /**
     * Generate random number
     *
     * @return random number
     */
    private int randomNumber() {
        return (int) (Math.random()
                * (MAX_GRID_SIZE) + 1);
    }
}