/*
 * Copyright 2007 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.dev.typeinfo.test;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.BadTypeArgsException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JConstructor;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.ParseException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.core.ext.typeinfo.TypeOracleException;
import com.google.gwt.dev.javac.TypeOracleMediator;
import com.google.gwt.dev.util.log.AbstractTreeLogger;
import com.google.gwt.dev.util.log.PrintWriterTreeLogger;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class InteractiveTypeOracle {

  public static interface CommandHandler {
    /**
     * Specifies the keyword causes this handler to be invoked.
     */
    String getCommandToken();

    /**
     * Executes the command given the specified args, writing the results or an
     * error.
     * 
     * @return <code>false</code> if there was a problem, in which case the
     *         error description will have been written to results
     */
    boolean process(TreeLogger logger, String[] args);

    boolean requiresCurrentType();
  }

  public static void main(String[] args) throws UnableToCompleteException {
    AbstractTreeLogger logger = new PrintWriterTreeLogger();

    // See if we should create a gui logger.
    // TODO: this was removed to avoid making an SWT dependency from test code
    //
    // for (int i = 0; i < args.length; i++) {
    // if ("-gui".equals(args[i])) {
    // logger = TreeLoggerWidget.getAsDetachedWindow(
    // "Interactive Type Oracle Log", 700, 600, true);
    // break;
    // }
    // }

    String logLevel = System.getProperty("gwt.logLevel");
    if (logLevel != null) {
      logger.setMaxDetail(TreeLogger.Type.valueOf(logLevel));
    }

    InputStreamReader isr = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(isr);

    // Build an oracle.
    //
    TypeOracleMediator mediator = new TypeOracleMediator();
    TypeOracle oracle = mediator.getTypeOracle();
    // TODO: add compilation units

    // Create an interactive wrapper around the oracle.
    //
    InteractiveTypeOracle ito = new InteractiveTypeOracle(oracle);

    try {
      String command;
      System.out.print("> ");
      System.out.flush();
      while (null != (command = br.readLine())) {
        ito.processCommand(logger, command);
        System.out.print("> ");
        System.out.flush();
      }
    } catch (IOException e) {
      System.err.println("Error reading stdin");
      e.printStackTrace();
    }
  }

  public InteractiveTypeOracle(TypeOracle oracle) {
    this.oracle = oracle;
    registerCommandHandler(cmdHelp);
    registerCommandHandler(cmdParse);
    registerCommandHandler(cmdSelectType);
    registerCommandHandler(cmdAllTypes);
    registerCommandHandler(cmdSubtypes);
    registerCommandHandler(cmdSupertypes);
    registerCommandHandler(cmdEnclosing);
    registerCommandHandler(cmdOverloads);
    registerCommandHandler(cmdNested);
    registerCommandHandler(cmdConstructors);
    registerCommandHandler(cmdMethods);
    registerCommandHandler(cmdFields);
  }

  public boolean processCommand(TreeLogger logger, String command) {
    String[] tokens = command.split("[ \t]");
    return processCommand(logger, tokens);
  }

  public boolean processCommand(TreeLogger logger, String[] tokens) {
    if (tokens.length == 0) {
      logger.log(TreeLogger.WARN, "Expecting a command", null);
      return false;
    }

    CommandHandler handler = handlers.get(tokens[0]);
    if (handler == null) {
      logger.log(TreeLogger.WARN, "Unknown command: " + tokens[0], null);
      cmdHelp.process(logger, new String[0]);
      return false;
    }

    if (currType == null && handler.requiresCurrentType()) {
      logger.log(TreeLogger.WARN,
          "This command requires a current type to be selected", null);
      return false;
    }

    String[] args = new String[tokens.length - 1];
    System.arraycopy(tokens, 1, args, 0, args.length);
    return handler.process(logger, args);
  }

  /**
   * Registers a command handler.
   * 
   * @return if not <code>null</code>, the previous handler for the same
   *         command token
   */
  public CommandHandler registerCommandHandler(CommandHandler handler) {
    String token = handler.getCommandToken();
    CommandHandler old = handlers.put(token, handler);
    return old;
  }

  private final CommandHandler cmdAllTypes = new CommandHandler() {

    public String getCommandToken() {
      return "all-types";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments expected", null);
        logger.log(TreeLogger.INFO, "Usage: all-types", null);
        logger.log(TreeLogger.INFO, "Prints all known types", null);
        return false;
      }

      JClassType[] types = oracle.getTypes();
      oracle.sort(types);
      TreeLogger sublogger = null;
      for (int i = 0; i < types.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "All known types", null);
        }
        JClassType type = types[i];
        String typename = type.getQualifiedSourceName();
        sublogger.log(TreeLogger.INFO, typename, null);
      }
      return true;
    }

    public boolean requiresCurrentType() {
      return false;
    }
  };

  private final CommandHandler cmdHelp = new CommandHandler() {

    public String getCommandToken() {
      return "help";
    }

    public boolean process(TreeLogger logger, String[] args) {
      TreeLogger sublogger = null;
      Set<String> keySet = handlers.keySet();
      String[] cmdTokens = keySet.toArray(new String[keySet.size()]);
      for (int i = 0; i < cmdTokens.length; i++) {
        String cmdToken = cmdTokens[i];
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Available commands", null);
        }
        sublogger.log(TreeLogger.INFO, cmdToken, null);
      }
      return true;
    }

    public boolean requiresCurrentType() {
      return false;
    }
  };

  private final CommandHandler cmdSelectType = new CommandHandler() {

    public String getCommandToken() {
      return "select";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 1) {
        logger.log(TreeLogger.WARN, "Expected a type name", null);
        logger.log(TreeLogger.INFO, "Usage: select <typename>", null);
        return false;
      }

      String typename = args[0];
      JClassType type = oracle.findType(typename);
      if (type == null) {
        logger.log(TreeLogger.WARN, "Cannot find type " + typename, null);
        return false;
      }

      currType = type;
      logger.log(TreeLogger.INFO, "Current type is now "
          + type.getQualifiedSourceName(), null);
      return true;
    }

    public boolean requiresCurrentType() {
      return false;
    }
  };

  private final CommandHandler cmdSubtypes = new CommandHandler() {

    public String getCommandToken() {
      return "subtypes";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments expected", null);
        logger.log(TreeLogger.INFO, "Usage: subtypes", null);
        logger.log(TreeLogger.INFO, "Prints all subtypes of the current type",
            null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      TreeLogger sublogger = null;

      JClassType[] subtypes = currType.getSubtypes();
      oracle.sort(subtypes);
      for (int i = 0; i < subtypes.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Subtypes of " + typename,
              null);
        }
        sublogger.log(TreeLogger.INFO, subtypes[i].getQualifiedSourceName(),
            null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdFields = new CommandHandler() {

    public String getCommandToken() {
      return "fields";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments expected", null);
        logger.log(TreeLogger.INFO, "Usage: fields", null);
        logger.log(TreeLogger.INFO, "Prints the fields of the current type",
            null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      TreeLogger sublogger = null;
      JField[] fields = currType.getFields();
      oracle.sort(fields);
      for (int i = 0; i < fields.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Fields of " + typename,
              null);
        }
        sublogger.log(TreeLogger.INFO, fields[i].toString(), null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdMethods = new CommandHandler() {

    public String getCommandToken() {
      return "methods";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments expected", null);
        logger.log(TreeLogger.INFO, "Usage: methods", null);
        logger.log(TreeLogger.INFO, "Prints the methods of the current type",
            null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      TreeLogger sublogger = null;
      JMethod[] methods = currType.getMethods();
      oracle.sort(methods);
      for (int i = 0; i < methods.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Methods of " + typename,
              null);
        }
        sublogger.log(TreeLogger.INFO, methods[i].toString(), null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdNested = new CommandHandler() {

    public String getCommandToken() {
      return "nested";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments expected", null);
        logger.log(TreeLogger.INFO, "Usage: nested", null);
        logger.log(TreeLogger.INFO,
            "Prints the nested types of the current type", null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      TreeLogger sublogger = null;
      JClassType[] nestedTypes = currType.getNestedTypes();
      oracle.sort(nestedTypes);
      for (int i = 0; i < nestedTypes.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Types nested inside "
              + typename, null);
        }
        sublogger.log(TreeLogger.INFO, nestedTypes[i].toString(), null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdParse = new CommandHandler() {

    public String getCommandToken() {
      return "parse";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length == 0) {
        logger.log(TreeLogger.WARN, "At least one argument expected", null);
        logger.log(TreeLogger.INFO, "Usage: parse ...", null);
        logger.log(TreeLogger.INFO, "Parses a string into a type", null);
        return false;
      }

      String mushed = "";
      for (int i = 0; i < args.length; i++) {
        mushed += args[i];
      }

      try {
        JType type = oracle.parse(mushed);
        logger.log(TreeLogger.INFO, type.getQualifiedSourceName(), null);
      } catch (NotFoundException e) {
        logger.log(TreeLogger.WARN, "Could not find type", e);
      } catch (ParseException e) {
        logger.log(TreeLogger.WARN, "Unable to parse " + mushed, e);
      } catch (BadTypeArgsException e) {
        logger.log(TreeLogger.WARN, "Bad arguments " + mushed, e);
      } catch (TypeOracleException e) {
        logger.log(TreeLogger.WARN,
            "Some other type oracle exception while parsing " + mushed, e);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return false;
    }
  };

  private final CommandHandler cmdEnclosing = new CommandHandler() {

    public String getCommandToken() {
      return "enclosing";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments", null);
        logger.log(TreeLogger.INFO, "Usage: enclosing", null);
        logger.log(TreeLogger.INFO,
            "Prints the enclosing type of the current type", null);
        return false;
      }

      JClassType enclosingType = currType.getEnclosingType();
      if (enclosingType != null) {
        logger.log(TreeLogger.INFO, enclosingType.getQualifiedSourceName(),
            null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdConstructors = new CommandHandler() {

    public String getCommandToken() {
      return "ctors";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments", null);
        logger.log(TreeLogger.INFO, "Usage: ctors", null);
        logger.log(TreeLogger.INFO,
            "Prints the constructors of the current type", null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      JConstructor[] ctors = currType.getConstructors();
      oracle.sort(ctors);
      TreeLogger sublogger = null;
      for (int i = 0; i < ctors.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Constructors of "
              + typename, null);
        }
        sublogger.log(TreeLogger.INFO, ctors[i].toString(), null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdOverloads = new CommandHandler() {

    public String getCommandToken() {
      return "overloads";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 1) {
        logger.log(TreeLogger.WARN, "One argument is expected", null);
        logger.log(TreeLogger.INFO, "Usage: overloads <method-name>", null);
        logger.log(TreeLogger.INFO,
            "Prints the overloads of a particular method in the current type",
            null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      JMethod[] overloads = currType.getOverloads(args[0]);
      oracle.sort(overloads);
      TreeLogger sublogger = null;
      for (int i = 0; i < overloads.length; i++) {
        if (sublogger == null) {
          sublogger = logger.branch(TreeLogger.INFO, "Overloads in " + typename
              + " of " + args[0], null);
        }
        sublogger.log(TreeLogger.INFO, overloads[i].toString(), null);
      }

      return true;
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private final CommandHandler cmdSupertypes = new CommandHandler() {
    public String getCommandToken() {
      return "supertypes";
    }

    public boolean process(TreeLogger logger, String[] args) {
      if (args.length != 0) {
        logger.log(TreeLogger.WARN, "No arguments", null);
        logger.log(TreeLogger.INFO, "Usage: supertypes", null);
        logger.log(TreeLogger.INFO,
            "Prints the hierarchy of supertypes of the current type", null);
        return false;
      }

      String typename = currType.getQualifiedSourceName();
      logger = logger.branch(TreeLogger.INFO, "Supertypes of " + typename, null);
      printSupertypesImpl(logger, currType);
      return true;
    }

    private void printSupertypesImpl(TreeLogger parentLogger, JClassType type) {
      TreeLogger childLogger;

      // Superclass
      JClassType superclass = type.getSuperclass();
      if (superclass != null) {
        String name = superclass.getQualifiedSourceName();
        childLogger = parentLogger.branch(TreeLogger.INFO, name, null);
        printSupertypesImpl(childLogger, superclass);
      }

      // Superinterfaces
      JClassType[] superintfs = type.getImplementedInterfaces();
      for (int i = 0; i < superintfs.length; i++) {
        JClassType superintf = superintfs[i];
        String name = superintf.getQualifiedSourceName();
        childLogger = parentLogger.branch(TreeLogger.INFO, name, null);
        printSupertypesImpl(childLogger, superintf);
      }
    }

    public boolean requiresCurrentType() {
      return true;
    }
  };

  private JClassType currType;
  private final Map<String, CommandHandler> handlers = new HashMap<String, CommandHandler>();
  private final TypeOracle oracle;
}