import java.util.*;

public class WordCount {

    public static void main (String[] argv)
    {
        countWordsInFileUsingTree ("testfile");
	countWordsInFileUsingList ("testfile");
    }


    static void countWordsInFileUsingTree (String fileName)
    {
	// Create an instance of the data structure.
        BinaryTreeMap3 tree = new BinaryTreeMap3 ();

	// Read a text file and extract the words into an array.
        String[] words = WordTool.readWords (fileName);
        System.out.println ("Read in " + words.length + " words");

	// Put words into data structure. If a word repeats, increment its count.
        for (int i=0; i<words.length; i++) {
            if (! tree.contains (words[i]) ) {
                tree.add ( new KeyValuePair (words[i], new Integer(1)) );
            }
            else {
                // Increment count.
                KeyValuePair kvp = tree.getKeyValuePair (words[i]);
		Integer count = (Integer) kvp.value;
                kvp.value = new Integer (count+1);
            }
        }

	// Note use of array:
        KeyValuePair[] uniqueWords = tree.getAllKeyValuePairs ();
        System.out.println ("Found " + uniqueWords.length + " unique words");

	// Sort the words by count.
        Arrays.sort (uniqueWords, new KeyValueComparator());
        for (int i=0; i < uniqueWords.length; i++) {
            System.out.println (uniqueWords[i].value + "  " + uniqueWords[i].key);
        }
    }


    static void countWordsInFileUsingList (String fileName)
    {
	// Our data structure is now a linked list.
        OurLinkedListMap list = new OurLinkedListMap ();

	// Get the text.
        String[] words = WordTool.readWords (fileName);
        System.out.println ("Read in " + words.length + " words");

	// Place words in data structure. If a word repeats, increment its count.
        for (int i=0; i<words.length; i++) {
            if (! list.contains (words[i]) ) {
                list.add ( new KeyValuePair (words[i], new Integer(1)) );
            }
            else {
                // Increment count.
                KeyValuePair kvp = list.getKeyValuePair (words[i]);
		Integer count = (Integer) kvp.value;
                kvp.value = new Integer (count+1);
            }
        }

	// Note use of array:
        KeyValuePair[] uniqueWords = list.getAllKeyValuePairs ();
        System.out.println ("Found " + uniqueWords.length + " unique words");

	// Sort by count and print.
        Arrays.sort (uniqueWords, new KeyValueComparator());
        for (int i=0; i < uniqueWords.length; i++) {
            System.out.println (uniqueWords[i].value + "  " + uniqueWords[i].key);
        }
    }


}


// This class is passed on to Java's sort algorithm (in 
// the Java library) to help with sorting. The idea is this:
// if you want Java's sort algorithm to sort your data, you
// have to tell it how to compare two pieces of data, especially
// if the data is of your own making (like KeyValuePair).

class KeyValueComparator implements Comparator<KeyValuePair> {

    // We decide how to compare two key-value pairs. Java's sort
    // algorithm will repeatedly call this as it compares elements.

    public int compare (KeyValuePair kvp1, KeyValuePair kvp2) 
    {
        // Note: the .value variable is of type Object. That's why we need the cast.
	Integer count1 = (Integer) kvp1.value;
	Integer count2 = (Integer) kvp2.value;

        if (count1 > count2) {        
            return -1;
        }
        else if (count1 < count2) {
            return 1;
        }
        else {
            return 0;
        }
    }


    // We're required to implement this as part of implementing
    // the interface.

    public boolean equals (Object obj)
    {
        return false;
    }

} //end-KeyValueComparator