OOP Game Control

package Configs;

import java.io.FileNotFoundException;
import java.io.FileWriter;

import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.filechooser.FileNameExtensionFilter;

import java.io.File;
import java.util.List;
import java.util.Scanner;

public class ExtHandle {

    private final String KV_KEY=":";        //Key that separates data name from data value.
    private final String DELIMITER_KEY=";"; //Key that separates data entries
    private final String SEPERATE_KEY=",";  //Key that separates array or listed data
    private final String NEWLINE_KEY="\n";  //New line key (Not used, but kept just in case).

    //These are the keys used when saving a game, so that we can restore it.
    private final String SAVE_DIM_X="dX";                       //Board horizontal cells key name.
    private final String SAVE_DIM_Y="dY";                       //Board vertical cells key name.
    private final String SAVE_PLAYERNAME="pName";               //Player name key name.
    private final String SAVE_PLAYERHEALTH="pHealth";           //Player health key name.
    private final String SAVE_PLAYERHEALTHTOTAL="totalhealth";  //Total health key name.
    private final String SAVE_MINESTRENGTH="minestrenght";      //Maximum mine strength key name.
    private final String SAVE_GAMETYPE="gType";                 //Game type key name.
    private final String SAVE_GAMETIMELIMIT="timelimit";        //Time limit key name.
    private final String SAVE_GAMETIMELEFT="timePassed";        //Time passed key name.
    private final String SAVE_MINECOUNT="mines";                //Mine count key name.
    private final String SAVE_MAPMATRIX="map";                  //Map key name.
    private final String SAVE_MINESTRENGTHMAP="minestrengthmap"; //Mine strength map key name.
    private final String SAVE_HISTORYMATRIX="history";          //Key name for history. Please note history is only saved, it is not restored.

    private final String FILE_MINESWEEPERMAP_EXT="msg"; // File extension (Stands for MineSweeperGame)

    private String currentGameBuffer; //Somewhere to store out loaded data, or data to be saved.

    private handler mainHNDLR; //Our communication line back to the execLoad class for the game handle.

    ExtHandle(handler mainHNDLR)
    {
        this.mainHNDLR=mainHNDLR;
    }

    public String gameToString(int[] fieldMatrix, int[] fieldDimension, int mineCount, String playerName, int gameTime, int timePassed, int gameMode, int playerHealth, int totalHealth, int mineStrength, int[] mineMap)
    /*
     * Inputs:
     *      fieldMatrix     -   Takes the current 1 dimensional field of the board.
     *      fieldDimension  -   Takes the 1 dimensional, 2 index board dimensions.
     *      mineCount       -   Takes the total mine count of the map.
     *      playerName      -   Takes the current player name.
     *      gameTime        -   Takes the starting amount of time allocated for the game.
     *      timeLeft        -   Takes how much time has passed.
     *      gameMode        -   What game mode is this?
     *      playerHealth    -   Takes current player health
     *      totalHealth     -   Takes the total health that was allocated at the start of the match.
     *      mineStrength    -   Takes the maximum mine strength.
     *      mineMap         -   Takes a 1 dimensional array of the mine strength map.
     *
     * Outputs:
     *      Passes out what ever gameToString() passes out.
     *
     * Process:
     *      This function will turn the current game to string. It overloads the other gameToString() function, which also takes the current game history as a parameter.
     */
    {
        return gameToString(fieldMatrix, fieldDimension, mineCount, playerName, gameTime, timePassed, gameMode, playerHealth, totalHealth, mineStrength, mineMap, null);

    }

    public void updateSettingsFromLoad(String loadedGame)
    /*
     * Inputs:
     *      loadedGame  -   Takes the string value of the game (usually from a file.)
     *
     * Outputs:
     *      None, it updates the settings automatically.
     *
     * Process:
     *      After loading the saved game string from a file (or memory), this function is run so that the game settings are updated.
     */
    {
        this.mainHNDLR.settings.setGameColumns(Integer.parseInt(getDataString(SAVE_DIM_X, loadedGame)));
        this.mainHNDLR.settings.setGameRows(Integer.parseInt(getDataString(SAVE_DIM_Y, loadedGame)));
        this.mainHNDLR.settings.setMineCount(Integer.parseInt(getDataString(SAVE_MINECOUNT, loadedGame)));
        this.mainHNDLR.settings.setTimeLimit(Integer.parseInt(getDataString(SAVE_GAMETIMELIMIT, loadedGame)));
        this.mainHNDLR.settings.setMineStrength(Integer.parseInt(getDataString(SAVE_MINESTRENGTH, loadedGame)));
        this.mainHNDLR.settings.setHealthLimit(Integer.parseInt(getDataString(SAVE_PLAYERHEALTHTOTAL, loadedGame)));
        this.mainHNDLR.settings.setGameType(Integer.parseInt(getDataString(SAVE_GAMETYPE, loadedGame)));
        this.mainHNDLR.settings.setPlayerName(getDataString(SAVE_PLAYERNAME, loadedGame));
    }

    public void updateSettingsFromLoad()
    /*
     * Inputs:
     *      None
     *
     * Outputs:
     *      None
     *
     * Process:
     *      If no string is specified for the updateSettingsFromLoad() function, then we'll use the current game string.
     */
    {
        updateSettingsFromLoad(this.mainHNDLR.extHandle.getGameStringBuffer());
    }

    public String gameToString(int[] fieldMatrix, int[] fieldDimension, int mineCount, String playerName, int gameTime, int timePassed, int gameMode, int playerHealth, int totalHealth, int mineStrength, int[] mineMap, List<int[]> gameHistory)
    /*
     * Inputs:
     *      fieldMatrix     -   Takes the current 1 dimensional field of the board.
     *      fieldDimension  -   Takes the 1 dimensional, 2 index board dimensions.
     *      mineCount       -   Takes the total mine count of the map.
     *      playerName      -   Takes the current player name.
     *      gameTime        -   Takes the starting amount of time allocated for the game.
     *      timeLeft        -   Takes how much time has passed.
     *      gameMode        -   What game mode is this?
     *      playerHealth    -   Takes current player health
     *      totalHealth     -   Takes the total health that was allocated at the start of the match.
     *      mineStrength    -   Takes the maximum mine strength.
     *      mineMap         -   Takes a 1 dimensional array of the mine strength map.
     *      gameHistory     -   A copy of the current game history in the form of a 2 dimensional array
     *
     * Outputs:
     *      Passes out what ever gameToString() passes out.
     *
     * Process:
     *      This function will turn the current game to string. Each of the parameters is placed into a string, according to its key name, separated by the key<>value delimiter key (a :), and finishes with the data field delimiter key (a ;). It also breaks upthe fieldMatrix[] array, the mineMap[] array and the gameHistory multi-dimensional array into comma separated values (CSV) for file storage.
     */
    {

        String theGame="";
        theGame+=SAVE_DIM_X + KV_KEY + fieldDimension[0]+DELIMITER_KEY;
        theGame+=SAVE_DIM_Y + KV_KEY + fieldDimension[1]+DELIMITER_KEY;
        theGame+=SAVE_MINECOUNT + KV_KEY + mineCount+DELIMITER_KEY;
        theGame+=SAVE_PLAYERNAME + KV_KEY + playerName + DELIMITER_KEY;
        theGame+=SAVE_GAMETIMELIMIT + KV_KEY + gameTime + DELIMITER_KEY;
        theGame+=SAVE_GAMETIMELEFT + KV_KEY + timePassed + DELIMITER_KEY;
        theGame+=SAVE_PLAYERHEALTH + KV_KEY + playerHealth + DELIMITER_KEY;
        theGame+=SAVE_PLAYERHEALTHTOTAL + KV_KEY + totalHealth + DELIMITER_KEY;
        theGame+=SAVE_MINESTRENGTH + KV_KEY + mineStrength + DELIMITER_KEY;
        theGame+=SAVE_GAMETYPE + KV_KEY + gameMode + DELIMITER_KEY;
        theGame+=SAVE_MAPMATRIX + KV_KEY;

        for (int i=0;i<fieldMatrix.length-1;i++) //Field matrix array
        {
            theGame+=fieldMatrix[i] + SEPERATE_KEY;
        }
        theGame+=mineMap[mineMap.length-1]+DELIMITER_KEY;

        theGame+=SAVE_MINESTRENGTHMAP + KV_KEY;

        for (int i=0;i<mineMap.length-1;i++) //Mine strength array
        {
            theGame+=mineMap[i] + SEPERATE_KEY;
        }
        theGame+=mineMap[mineMap.length-1]+DELIMITER_KEY;

        if (gameHistory!=null) { //Game history matrix
            for (int i=0;i<gameHistory.size();i++) {
                theGame+=SAVE_HISTORYMATRIX+"[" + i + "]" + KV_KEY;

                for (int j=0; j < gameHistory.get(i).length - 1; j++)
                {
                    theGame+=gameHistory.get(i)[j] + SEPERATE_KEY;
                }
                theGame+=gameHistory.get(i)[gameHistory.get(i).length-1]+DELIMITER_KEY;
            }
        }

        setGameStringBuffer(theGame);

        return theGame;
    }

    public void setGameStringBuffer(String currentGameString)
    /*
     * Inputs:
     *      currentGameString   -   The string you want to be set as the current game's string.
     *
     * Outputs:
     *      None
     *
     * Process:
     *      When saving a game, we want to pass the game's string from another class into this one, we do this by calling this function so that the game string is saved locally (to this class).
     */
    {
        currentGameBuffer=currentGameString;
        System.out.println("Game Saved String: ");
        System.out.println(currentGameBuffer);
    }

    public String getGameStringBuffer()
    /*
     * Inputs:
     *      None
     *
     * Outputs:
     *      The current game's string
     *
     * Process:
     *      This is the function we use (an accessor) to pass the  current game's string to another class.
     */
    {
        return currentGameBuffer;
    }

    public String getDataString(String dataName, String searchString)
    /*
     * Inputs:
     *      None
     *
     * Outputs:
     *      The current game's string
     *
     * Process:
     *      This is the function we use (an accessor) to pass the  current game's string to another class.
     */
    {
        int startPoint=searchString.indexOf(dataName + KV_KEY);

        if (startPoint<=-1) { return ""; }

        startPoint += (dataName + SEPERATE_KEY).length();

        String[] theData=searchString.substring(startPoint).split(DELIMITER_KEY);

        return theData[0];
      }

    public int[] getMapArr(String mapMatrix)
    /*
     * Inputs:
     *      mapMatrix   -   The current game string, which includes the map matrix (or mineStrength CSV).
     *
     * Outputs:
     *      An array of the mapMatrix (or mineStrength if that is what was passed in).
     *
     * Process:
     *      Basically cuts data that is separated by SEPERATE_KEY (a ,) into an int array. Is normally used when loading a map.
     */
    {

        String [] cutMatrix=mapMatrix.split(SEPERATE_KEY);

        int matrixLegnth=cutMatrix.length;
        int [] theReturn = new int[matrixLegnth];

        for (int i=0;i<matrixLegnth;i++)
        {
            theReturn[i]=Integer.parseInt(cutMatrix[i]);
        }
        return theReturn;
    }

    public boolean saveGame(String fileName, String gameData)
    /*
     * Inputs:
     *      fileName    -   Filename to save to, as a string.
     *      gameData    -   The game data to write to the file.
     *
     * Outputs:
     *      Returns saveGame(), see other saveGame() overloaded function.
     *
     * Process:
     *      Overloads the saveGame function, to allow input of a string as the file name, instead of a file object. See the overloaded function for more details.
     */
    {
        File saveFile = new File(fileName);
        return saveGame(saveFile, gameData);
    }

    public boolean saveGame(File fileName, String gameData)
    /*
     * Inputs:
     *      fileName    -   Filename to save to, as a file object.
     *      gameData    -   The game data to write to the file.
     *
     * Outputs:
     *      Returns true if the save was successful, or false if the exception was triggered.
     *
     * Process:
     *      Writes the data from gameData into a file.
     */
    {
        try {
            FileWriter objSaveFile = new FileWriter(fileName);
            objSaveFile.write(gameData);
            objSaveFile.close();
        }
        catch (Exception e) {
            System.out.println("Couldn't save the game.");
            return false;
        }
        return true;
    }

    public boolean deleteAutosave()
    /*
     * Inputs:
     *      None
     *
     * Outputs:
     *      Returns true if the autosave file was successfully deleted, or false if the exception was triggered.
     *
     * Process:
     *      Writes the data from gameData into a file.
     */
    {
        File deleteFile = new File(mainHNDLR.settings.getAutoSavePath());
        try {
            deleteFile.delete();
            System.out.println("Autosave file deleted.");
        } catch (Exception e) {
            System.out.println("Could not delete autosave file. It may not exist, or be read-only.");
            return false;
        }

        return true;
    }

    public boolean loadGame(String fileName)
    /*
     * Inputs:
     *      fileName    -   Filename, as a string to load. The overloaded function takes a file object.
     *
     * Outputs:
     *      Returns true if the file was successfully loaded, or false if the exception was triggered.
     *
     * Process:
     *      Reads data from the loadgame file, see the overloaded function for more details.
     */
    {
        File openFile = new File(fileName);
        return loadGame(openFile);
    }

    public boolean loadGame(File fileName)
    /*
     * Inputs:
     *      fileName    -   Filename, as a file object to load.
     *
     * Outputs:
     *      Returns true if the file was successfully loaded, or false if the exception was triggered.
     *
     * Process:
     *      Reads data from the loadgame file, and places it as the current game's string.
     */
    {
        String theGame="";
        try {
            Scanner lineBuffer = new Scanner(fileName);
            while (lineBuffer.hasNextLine()) {
                theGame = lineBuffer.nextLine();
            }
            lineBuffer.close();
        }
        catch (FileNotFoundException e) {
            System.out.println("Couldn't load game.");
            return false;
        }
        setGameStringBuffer(theGame);
        updateSettingsFromLoad();
        return true;
    }

    public boolean showSaveDialog(String whatToSave, JFrame whatCalled)
    /*
     * Inputs:
     *      whatToSave  -   The game data that we are saving.
     *      whatCalled  -   The window object that called this function. We take this so that we can lock control of said window.
     *
     * Outputs:
     *      Returns true if the file was successfully saved, or false if the exception was triggered.
     *
     * Process:
     *      Gets the game data, then displays the save dialog box, so that the user can choose where they would like to save their game. It then calls the saveGame() function to save said data to said file.
     */
    {
        JFileChooser saveDialog = new JFileChooser();
        FileNameExtensionFilter fileFilter = new FileNameExtensionFilter("Minesweeper Game (*." + FILE_MINESWEEPERMAP_EXT + ")", FILE_MINESWEEPERMAP_EXT);
        saveDialog.setFileFilter(fileFilter);
        int dialogReturn = saveDialog.showSaveDialog(whatCalled);

        if (dialogReturn != JFileChooser.CANCEL_OPTION) {
            File saveFile = saveDialog.getSelectedFile();
            if(!saveFile.toString().toLowerCase().endsWith(FILE_MINESWEEPERMAP_EXT)) { saveFile = new File(saveFile + FILE_MINESWEEPERMAP_EXT); } //Our very own MineSweeperGame file extension.
            return saveGame(saveFile, whatToSave);
        }

        return true;
    }

    public boolean showLoadDialog(JFrame whatCalled)
    /*
     * Inputs:
     *      whatCalled  -   The window object that called this function. We take this so that we can lock control of said window.
     *
     * Outputs:
     *      Returns true if the file was successfully loaded, or false if the exception was triggered.
     *
     * Process:
     *      Displays the save dialog box, so that the user can choose where their game was saved. It then calls reads the data from the file and calls setGameStringBuffer(), while updating the current game's settings with updateSettingsFromLoad();
     */
    {
        JFileChooser openDialog = new JFileChooser();
        FileNameExtensionFilter fileFilter = new FileNameExtensionFilter("Minesweeper Game (*." + FILE_MINESWEEPERMAP_EXT + ")", FILE_MINESWEEPERMAP_EXT);
        openDialog.setFileFilter(fileFilter);
        int dialogReturn = openDialog.showOpenDialog(whatCalled);

        if (dialogReturn != JFileChooser.CANCEL_OPTION) {
            String theGame="";
            File openFile = openDialog.getSelectedFile();
            try {
                Scanner lineBuffer = new Scanner(openFile);
                while (lineBuffer.hasNextLine()) {
                    theGame = lineBuffer.nextLine();
                }
                lineBuffer.close();
            }
            catch (FileNotFoundException e) {
                System.out.println("Couldn't find file.");
                return false;
            }
            setGameStringBuffer(theGame);
            updateSettingsFromLoad();
        }
        return true;
    }


}