import java.util.*;
import java.io.*;
import java.math.*;

/**
 * This program takes a given rack of letters (in an array)
 * and finds words in a dictionary file that can be
 * made from that given rack. Then, it computes the scores for
 * each matching word and returns them to the user based on
 * the desired word length (3-6 characters). Also, it has to
 * randomly select a 6 letter word from a generated text file.
 * Lastly, it needs to computer the top word score and the highest
 * word score per tile value.
 *
 *
 * @author Zach VanDuyn
 *
 * CS1122, Spring 2011
 * Bryan Franklin
 */


public class ScrabbleSolver
{
    private String dictFile;


    /**
     * Constructor for the ScrabbleSolver Object
     * This should create the files containing the lists of
     * 3-6 letter words and only 6 letter words, as well as initialize
     * any other class variables you need for the other methods
     *
     * @param dictFilename - filename of the dictionary text file
     * @param scoreFilename - filename of the letter score text file
     */
    public ScrabbleSolver(String dictFilename, String scoreFilename)
    {
        dictFile = dictFilename;
        Scanner in = null;
        try
        {
            in = new Scanner(new File(scoreFilename));
        }
        catch(Exception e)
        {
            System.out.println("Unable to access file: [" + scoreFilename + "]");
        }
        try{
            in = new Scanner(new File(dictFilename));
        }
        catch(Exception e)
        {
            System.out.println("Unable to access file: [" + dictFilename + "]");
        }


        PrintWriter dict36 = null;
        try {
            dict36 = new PrintWriter("words3-6.txt");
        } catch (FileNotFoundException e) {
            System.out.println("Unable to access file: words3-6.txt");
            e.printStackTrace();
        } //allows us to write to "words3-6.txt"
        PrintWriter dict6 = null;
        try {
            dict6 = new PrintWriter("words6.txt");
        } catch (FileNotFoundException e) {
            System.out.println("Unable to access file: words6.txt");
            e.printStackTrace();
        } //allows us to write to "words6.txt"

        while(in != null && in.hasNext())
        {
            String word = in.nextLine();
            if(word.length() > 2 && word.length() < 7) //makes sure the words length is between three and six
            {
                if(dict36 != null)
                    dict36.println(word);
                if(dict6 != null && word.length() == 6) //if it is exactly six in length - store it in the "words6.txt"
                {
                    dict6.println(word);
                }

            }
        }
        if(dict36 != null)
            dict36.close(); //closing the stream saves the changes on dict36 ("words3-6.txt")
        if(dict6 != null)
            dict6.close(); //closing the stream saves the changes on dict6 ("words6.txt")

    }

    /**
     * This method searches the scrabble dictionary for all
     * words that can be formed by the character array of letters
     *
     * @param theLetters - character array of the letters, can be of length 0-8
     * @return return an array of Strings of the words found in the dictionary,
     * followed by a space and their base scrabble score.
     *
     * For instance, if you find the word avatar, the array entry should be:
     * "avatar 9" as the letters a, t, r are all worth 1 point each and the
     * letter v is worth 4 points, totaling 9 points
     */
    //done with modification
    public String[] getAllMatchingWords(char[] theLetters)
    {
        for(int l = 0; l < theLetters.length; l++)
        {
            if(theLetters[l] < 'A' || theLetters[l] > 'z')
            {
                throw new IllegalArgumentException("Method [get3to6MatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");

            }
        }
        if(theLetters.length > 8)
        {
            throw new IllegalArgumentException("Method [getAllMatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");
        }

        ArrayList<String>matchingWords = new ArrayList<String>();
        Scanner in = null;
        try{
            in = new Scanner(new File(dictFile));
        }
        catch(Exception e)
        {
            System.out.println("Unable to access file: [" + dictFile + "]");
        }
        while(in != null && in.hasNext()) //for each word
        {
            boolean valid = true;
            String word = in.nextLine();
            String rack = new String(theLetters);
            for(int i = 0; i<word.length(); i++) //for each letter in word
            {
                char temp = word.charAt(i);  //the current letter in the word
                int t2 = rack.indexOf(temp); //index of the character on my rack
                if(t2 < 0) //if temp (the current letter) is not in the rack, then it is not a valid word
                {
                    valid = false;
                    break;
                }
                else
                {
                    if(t2 != 0) //if character is not in the first slot
                    {
                        if(t2 != rack.length()-1) //if this is not the last character in the rack

                            rack = rack.substring(0,t2)+rack.substring(t2 + 1);
                        else
                            rack = rack.substring(0, t2);
                    }
                    else //if the character is in index 0
                    {
                        if(rack.length() > 1)
                            rack = rack.substring(t2+1);  //remove the first character

                        else //if this is the last character in the rack
                            rack = "";  //set the rack to null
                    }
                }
            }
            if(valid)

            {
                int[] ArrayScores;
                ArrayScores = new int[26];
                Scanner read = null;
                int counter = 0;
                try
                {
                    read = new Scanner(new File("letterscores.txt"));
                }
                catch(Exception e)
                {
                    System.out.println("Unable to access file: [letterscores.txt]");
                }
                while(read.hasNext())
                {
                    read.next();
                    ArrayScores[counter] = read.nextInt();
                    counter++;
                }
                int count = 0;
                //this section reads the word and calculates it's score based on which characters it contains
                for(int i = 0; i < word.length(); i++)
                {
                    char letter = (""+word.charAt(i)).toLowerCase().charAt(0);
                    if(letter < 'A' || letter > 'z')
                    {
                        throw new IllegalArgumentException("Method [getAllMatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");

                    }
                    char temp = 'a';
                    for(int j = 0; j<26; j++)
                    {
                        if(letter == temp)
                        {
                            count += ArrayScores[j];
                            break;
                        }
                        temp++;
                    }
                }
                matchingWords.add(word+" "+count);
            }
        }

        String[] wordsArray = new String[matchingWords.size()];
        matchingWords.toArray(wordsArray);
        return wordsArray;

    }

    /**
     * This method searches the scrabble dictionary for all
     * words that can be formed by the character array of letters
     *
     * @param theLetters - character array of the letters, can be of length 0-8
     * @return return an array of Strings of the words found in the dictionary of
     * 3-6 length words, followed by a space and their base scrabble score.
     *
     * For instance, if you find the word avatar, the array entry should be:
     * "avatar 9" as the letters a, t, r are all worth 1 point each and the
     * letter v is worth 4 points, totaling 9 points
     */
    //done
    public String[] get3to6MatchingWords(char[] theLetters)
    {
        for(int k = 0; k<theLetters.length; k++)
        {
            if(theLetters[k] < 'A' || theLetters[k] > 'z')
            {
                throw new IllegalArgumentException("Method [get3to6MatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");

            }
        }
        if(theLetters.length > 8)
        {
            throw new IllegalArgumentException("Method [get3to6MatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");
        }
        Scanner in = null;

        ArrayList<String>matchingWords = new ArrayList<String>();
        try
        {
            in = new Scanner(new File(dictFile));
        }
        catch(Exception e)
        {
            System.out.println("Unable to access file: [" + dictFile + "]");
        }
        while(in != null && in.hasNext())
        {
            boolean valid = true;
            String word = in.nextLine(); //scrolls down the file
            String rack = new String(theLetters);
            if(word.length() > 2 && word.length() < 7)
            {
                //TLDR; this section of code removes characters that have been used in order to match words correctly.
                //It took a while to figure out how to use substring and indexOf to correctly remove the object and
                //have the counter correctly reset and move after the rack was modified in order to hit all the objects.
                for(int i = 0; i<word.length(); i++)
                {
                    char temp = word.charAt(i);
                    if(rack.indexOf(temp) == -1)
                    {
                        valid = false;
                        break;
                    }
                    else
                    {

                        int t2 = rack.indexOf(temp);
                        if(t2 > 0)
                        {
                            if(t2 < rack.length()-1)

                                rack = rack.substring(0,t2)+rack.substring(t2 + 1);
                            else
                                rack = rack.substring(0, t2);
                        }
                        else
                        {
                            if(t2 < rack.length()-1)
                                rack = rack.substring(t2+1);

                            else
                                rack = "";
                        }
                    }
                }
                if(valid)
                {
                    int[] ArrayScores;
                    ArrayScores = new int[26];
                    Scanner read = null;
                    int counter = 0;
                    try
                    {
                        read = new Scanner(new File("letterscores.txt"));
                    }
                    catch(Exception e)
                    {
                        System.out.println("Unable to access file: [letterscores.txt]");
                        return null;
                    }
                    while(read.hasNext())
                    {
                        read.next();
                        ArrayScores[counter] = read.nextInt();
                    }
                    int count = 0;
                    for(int i = 0; i < word.length(); i++)
                    {
                        char letter = (""+word.charAt(i)).toLowerCase().charAt(0);
                        if(letter < 'A' || letter > 'z')
                        {
                            throw new IllegalArgumentException("Method [get3to6MatchingWords] had an invalid parameter [theLetters], so the program cannot run correctly.");

                        }
                        char temp = 'a';
                        for(int j = 0; j<26; j++)
                        {
                            if(letter == temp)
                            {
                                count += ArrayScores[j];
                                j = 27;
                            }
                            temp++;
                        }
                    }
                    matchingWords.add(word+" "+count); //add the string and numeric score to a slot in the ArrayList
                }
            }
        }

        String[] wordsArray = new String[matchingWords.size()];
        matchingWords.toArray(wordsArray);
        return wordsArray;

    }


    /**
     * This method takes in a String array of words and scores and selects the top scoring word
     * and returns it
     *
     * @param theWords - String array formatted like the output from the getAllMatchingWords
     * method
     * @return - String containing the word and score of the top scoring word in the String Array
     */
    //done with modification
    public String getTopScoreWord(String[] theWords)
    {
        String word = null;
        int newScore = -1;
        int score = -1;
        for(int i = 0; i < theWords.length; i++) //iterates through theWords
        {
            String[] splitWords = theWords[i].split(" "); //defines delimiter as a space
            try
            {
                newScore = new Integer(splitWords[1]); //uses split words to grab only the numeric value
            }
            catch(NumberFormatException e)
            {
                throw new IllegalArgumentException("Method [getTopScoreWord] had an invalid parameter [theWords], so the program cannot run correctly.");
            }
            if(score<newScore) //if new score is larger than the previous score - store it as score
            {
                score = newScore;
                word = theWords[i];
            }
        }
        if(word == null)
            throw new IllegalArgumentException("Method [getTopScoreWord] had an invalid parameter [theWords], so the program cannot run correctly.");
        return word;
    }


    /**
     * This method takes in a String array of words and scores and returns the word with the
     * highest score per tile value (score/length)
     *
     * @param theWords - String array formatted like the output from the getAllMatchingWords
     * method
     * @return - String containing the word and score word with the highest score per tile
     * value in the String array
     */
    //done with modification
    public String getTopScorePerTileWord(String[] theWords)
    {
        if(theWords == null)
        {
            throw new IllegalArgumentException("Method [getTopScorePerTileWord] had an invalid parameter [theWords], so the program cannot run correctly.");
        }
        double highestRatio = 0; //stores the highest ratio found among theWords
        int index = -1;
        for(int i = 0; i < theWords.length; i++)
        {

            String[] splitWords = theWords[i].split(" "); //defines delimiter as a space
            double wordscore = -1;

            if(splitWords != null)
            {
                double wordlength = splitWords[0].length(); //calculates the word length
                try{
                    wordscore = new Integer(splitWords[1]); //separates the wordscore from the word
                }
                catch(NumberFormatException e)
                {
                    throw new IllegalArgumentException("Method [getTopScorePerTileWord] had an invalid parameter [theWords], so the program cannot run correctly.");

                }
                if(wordscore != -1)
                {
                    double currentRatio = (wordscore/wordlength); //finds the ratio of the current word
                    if(currentRatio>highestRatio) //if this newly calculated ratio is higher than the previously stored ratio - replace it
                    {
                        highestRatio = currentRatio;
                        index = i;
                    }
                }
            }
            else
            {
                throw new IllegalArgumentException("Method [getTopScorePerTileWord] had an invalid parameter [theWords], so the program cannot run correctly.");
            }
        }
        if(index == -1) //edge case condition
        {
            throw new IllegalArgumentException("Method [getTopScorePerTileWord] had an invalid parameter [theWords], so the program cannot run correctly.");
        }
        return theWords[index];
    }


    /**
     * This method returns a random word from the file containing only 6 letter words
     *
     * It should NOT append the scrabble score to the word.
     *
     * HINT:  Math.random() will probably be very useful for this method.
     *
     * @return - String of the 6 letter word found
     */
    //done with modification
    public String random6LetterWord()
    {
        Scanner in = null;
        try {
            in = new Scanner(new File("words6.txt"));
        } catch (FileNotFoundException e) {
            System.out.println("Unable to access the file: [words6.txt]");
            e.printStackTrace();
            return null;
        } //reads in already separated 6 letter words
        ArrayList<String> randomArray = new ArrayList<String>(); //create new ArrayList to store 6 letter words
        while(in.hasNext())
        {
            randomArray.add(in.nextLine()); //add text from "words6.txt" to cell in ArrayList
        }
        if(!randomArray.isEmpty())
        {
            String randomWord = randomArray.get((int)(Math.random()*randomArray.size())); //generate a random cell in the ArrayList (had to multiply by Array size to get whole numbers)
            return randomWord.split(" ")[0]; //again use space as delimiter - but only return first half (ignore the score)
        }
        else
        {
            return null;
        }

    }

}