package cse1030.games.wordgames;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

/**
 * A utility class containing methods related to word games.
 * 
 * @author CSE1030_W14
 * 
 */
public class WordGamesUtil {

  /**
   * A dictionary of lower case English words. The dictionary cannot be
   * modified. 
   */
  public static final Dictionary DICTIONARY = Dictionary.INSTANCE;

  
  /**
   * Private constructor to prevent instantiation.
   */
  private WordGamesUtil() {
    throw new UnsupportedOperationException();
  }
  
  
  /**
   * Determines if two strings are adjacent words. The string <code>s</code> is
   * adjacent to <code>t</code> if and only if all of the following conditions
   * are <code>true</code>:
   * 
   * <ul>
   * <li>the string <code>s</code> is in
   * <code>WordGamesUtility.DICTIONARY</code></li>
   * <li>the string <code>t</code> is in
   * <code>WordGamesUtility.DICTIONARY</code></li>
   * <li>the string <code>s</code> is the same length as <code>t</code></li>
   * <li><code>s</code> and <code>t</code> are identical except in exactly one
   * position</li>
   * </ul>
   * 
   * @param s
   *          a string
   * @param t
   *          a string
   * @return <code>true</code> if <code>s</code> and <code>t</code> are
   *         adjacent, and <code>false</code> otherwise
   */
  public static boolean areAdjacent(String s, String t) {
    // is s in the dictionary?
    if (!WordGamesUtil.DICTIONARY.contains(s)) {
      return false;
    }

    // is t in the dictionary?
    if (!WordGamesUtil.DICTIONARY.contains(t)) {
      return false;
    }

    // do s and t have the same length?
    if (s.length() != t.length()) {
      return false;
    }

    // count the number of letters n that are different in s and t
    int n = 0;
    for (int i = 0; i < s.length(); i++) {
      if (s.charAt(i) != t.charAt(i)) {
        n++;
      }
    }
    return n == 1;
  }

  /**
   * Returns a sorted set of all words in
   * <code>WordGamesUtility.DICTIONARY</code> that are adjacent to the string
   * <code>s</code>. The sorting of the elements of the set is lexicographical
   * (dictionary order).
   * 
   * @param s
   *          a string
   * @return a sorted set of words in <code>WordGamesUtility.DICTIONARY</code>
   *         that are adjacent to <code>s</code>
   */
  public static SortedSet<String> allAdjacentTo(String s) {
    SortedSet<String> result = new TreeSet<String>();
    for (String word : DICTIONARY) {
      if (areAdjacent(word, s)) {
        result.add(word);
      }
    }
    return result;
  }

  /**
   * Determines if the string <code>s</code> is an isogram. This method returns
   * <code>true</code> if and only if all of the following conditions are
   * <code>true</code>:
   * 
   * <ul>
   * <li>the string <code>s</code> is in
   * <code>WordGamesUtility.DICTIONARY</code></li>
   * <li>all of the letters in <code>s</code> occur only once</li>
   * </ul>
   * 
   * @param s
   *          a string
   * @return <code>true</code> if <code>a</code> is an isogram of <code>s</code>
   *         , and <code>false</code> otherwise
   */
  public static boolean isIsogram(String s) {
    // is s in the dictionary?
    if (!WordGamesUtil.DICTIONARY.contains(s)) {
      return false;
    }

    Set<Character> letters = new TreeSet<Character>(WordGamesUtil.toList(s));

    return letters.size() == s.length();
  }

  /**
   * Returns a sorted set of all isograms in
   * <code>WordGamesUtility.DICTIONARY</code>. The sorting of the elements of
   * the set is lexicographical (dictionary order).
   * 
   * @return a sorted set of isograms in
   *         <code>WordGamesUtility.DICTIONARY</code>
   */
  public static SortedSet<String> allIsograms() {
    SortedSet<String> result = new TreeSet<String>();

    for (String word : DICTIONARY) {
      if (isIsogram(word)) {
        result.add(word);
      }
    }

    return result;
  }

  /**
   * Returns a new list containing each character in the string <code>s</code>
   * in the same order that they appear in <code>s</code>
   * 
   * @param s
   *          a string
   * @return a new list containing each character in the string <code>s</code>
   *         in the same order that they appear in <code>s</code>
   */
  public static List<Character> toList(String s) {
    List<Character> t = new ArrayList<Character>();
    for (int i = 0; i < s.length(); i++) {
      t.add(s.charAt(i));
    }
    return t;
  }

  /**
   * Returns a new string formed by concatenating all of the characters stored
   * in the given list in sequential order (from the first element to the last
   * element).
   * 
   * @param t
   *          a list of characters
   * @return a string formed by concatenating the characters stored in
   *         <code>t</code> in sequential order
   */
  public static String fromList(List<Character> t) {
    StringBuilder b = new StringBuilder();
    for (Character c : t) {
      b.append(c);
    }
    return b.toString();
  }

  /**
   * Determines if a string is an anagram of a second string. This method
   * returns <code>true</code> if and only if all of the following conditions
   * are <code>true</code>:
   * 
   * <ul>
   * <li>the string <code>a</code> is in
   * <code>WordGamesUtility.DICTIONARY</code></li>
   * <li>the string <code>s</code> is in
   * <code>WordGamesUtility.DICTIONARY</code></li>
   * <li>the string <code>a</code> is the same length as <code>s</code></li>
   * <li>all of the letters in <code>a</code> occur with the same frequency as
   * the letters in <code>s</code></li>
   * </ul>
   * 
   * @param a
   *          a string
   * @param s
   *          another string
   * @return <code>true</code> if <code>a</code> is an anagram of <code>s</code>
   *         , and <code>false</code> otherwise
   */
  public static boolean isAnagramOf(String a, String s) {
    if (!WordGamesUtil.DICTIONARY.contains(a)) {
      return false;
    }
    if (!WordGamesUtil.DICTIONARY.contains(s)) {
      return false;
    }
    List<Character> aAsList = WordGamesUtil.toList(a);
    List<Character> sAsList = WordGamesUtil.toList(s);
    Collections.sort(aAsList);
    Collections.sort(sAsList);
    return aAsList.equals(sAsList);
  }

  /**
   * Returns a new string containing all of the letters of the given string in a
   * new random order. The scrambled string has the same length as
   * <code>s</code>, and is created by randomly shuffling the order of the
   * letters in <code>s</code>. All possible permutations of the letters of
   * <code>s</code> are expected to occur with approximately equal likelihood.
   * 
   * @param s
   *          a string
   * @return an new string having the same length as <code>s</code>, and
   *         containing all of the letters of <code>s</code> in a new random
   *         order
   */
  public static String scramble(String s) {
    List<Character> sAsList = toList(s);
    Collections.shuffle(sAsList);
    return fromList(sAsList);
  }
}