package org.lsst.ccs.command;
   
   import java.util.HashSet;
   import java.util.List;
   import java.util.Set;
   import java.util.SortedSet;
   import java.util.TreeSet;
   
   /**
   * Performs command completion, based on the information available in the
   * command dictionary. This is designed to be jline compatible, but not actually
   * implement jline's command completer to avoid adding a permanent dependency on
   * jline.
   *
   * @author tonyj
   */
  public class DictionaryCompleter {
      
      private final Dictionary dict;
  
      /**
       * Create a command completer for the given dictionary.
       *
       * @param dict
       */
      public DictionaryCompleter(Dictionary dict) {
          this.dict = dict;
      }
  
      /**
       * Generate a list of possible command completions.
       *
       * @param buffer The current content of the input line
       * @param index The index within the input line of the cursor
       * @param list A list which this routine should fill with possible command
       * completions.
       * @return The position at which the cursor should be positioned prior to
       * adding any of the returned items to the buffer.
       */
      public int complete(String buffer, int index, List<CharSequence> list) {
          TokenizedCommand tc = new TokenizedCommand(buffer.substring(0, index));
          int argCount = tc.getArgumentCount();
          boolean endsWithWhiteSpace = !tc.isEmpty() && Character.isWhitespace(buffer.charAt(index - 1));
          if (endsWithWhiteSpace) {
              argCount++;
          }
          if (tc.isEmpty()) {
              SortedSet<CharSequence> set = new TreeSet<>();
              for (DictionaryCommand def : dict) {
                  String command = def.getCommandName();
                  command += " ";
                  set.add(command);
                  for (String alias : def.getAliases()) {
                      alias += " ";
                      set.add(alias);
                  }
              }
              
              list.addAll(set);
          } else if (argCount == 0) {
              String prefix = tc.getCommand();
              SortedSet<CharSequence> set = new TreeSet<>();
              Set<DictionaryCommand> uniqueCommands = new HashSet<>();
              for (DictionaryCommand def : dict) {
                  String command = def.getCommandName();
                  if (command.startsWith(prefix)) {
                      command += " ";
                      set.add(command);
                      uniqueCommands.add(def);
                  }
                  for (String alias : def.getAliases()) {
                      if (alias.startsWith(prefix)) {
                          alias += " ";
                          set.add(alias);
                          uniqueCommands.add(def);
                      }
                  }
              }
              // Special case, if there are >1 matching commands, but they are all just
              // aliases for the same command, only return the actual command
              if (set.size() > 1 && uniqueCommands.size() == 1) {
                  list.add(uniqueCommands.iterator().next().getCommandName()+" ");
              } else {
                  list.addAll(set);
              }
              return tc.getCommandLocation();
          } else {
              String command = tc.getCommand();
              String lastArg = endsWithWhiteSpace ? "" : tc.getArgument(argCount - 1);
              for (DictionaryCommand def : dict) {
                  if (def.matchesCommandOrAlias(command) && (def.getArguments().length >= argCount || def.isVarArgs())) {
                      final DictionaryArgument currentArg = def.getArguments()[Math.min(argCount, def.getArguments().length) - 1];
                      List<String> values = currentArg.getValues();
                      if (values.isEmpty()) {
                          // The argument is not an enumeration, return argument description, prefixed with # 
                          list.add("# " + currentArg.getName() + " " + currentArg.getSimpleType() + " " + currentArg.getDescription());
                      } else {
                          // The argument is an enumeration, list possible values    
                          for (String value : values) {
                             if (startsWithIgnoreCase(value,lastArg)) {
                                 value += " ";
                                 list.add(value);
                             }
                         }
                     }
                 }
             }
             return endsWithWhiteSpace ? index : tc.getArgumentLocation(argCount - 1);
         }
         return index;
     }
     private static boolean startsWithIgnoreCase(String reference, String test) {
         if (test.length()>reference.length()) return false;
         return reference.substring(0,test.length()).equalsIgnoreCase(test);
     }
 }