/*
 * Copyright 2011 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.javac;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.HelpInfo;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.dev.CompilerContext;
import com.google.gwt.dev.javac.CompilationUnitBuilder.GeneratedCompilationUnit;
import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.InternalCompilerException.NodeInfo;
import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.util.Messages;
import com.google.gwt.dev.util.Util;
import com.google.gwt.thirdparty.guava.common.collect.Lists;

import org.eclipse.jdt.core.compiler.CategorizedProblem;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Set;

/**
 * Handles some details of reporting errors in {@link CompilationUnit}s to the
 * console.
 */
public class CompilationProblemReporter {

  /**
   * Traverses a set of compilation units to record enough information to enable accurate and
   * detailed compilation error cause traces.
   */
  public static void indexErrors(CompilationErrorsIndex compilationErrorsIndex,
      List<CompilationUnit> units) {
    for (CompilationUnit unit : units) {
      if (unit.isError()) {
        Dependencies dependencies = unit.getDependencies();
        compilationErrorsIndex.add(unit.getTypeName(), unit.getResourceLocation(),
            dependencies.getApiRefs(), CompilationProblemReporter.formatErrors(unit));
      }
    }
  }

  /**
   * Used as a convenience to catch all exceptions thrown by the compiler. For
   * instances of {@link InternalCompilerException}, extra diagnostics are
   * printed.
   *
   * @param logger logger used to report errors to the console
   * @param e the exception to analyze and log
   * @return Always returns an instance of {@link UnableToCompleteException} so
   *         that the calling method can declare a more narrow 'throws
   *         UnableToCompleteException'
   */
  public static UnableToCompleteException logAndTranslateException(TreeLogger logger, Throwable e) {
    if (e instanceof UnableToCompleteException) {
      // just rethrow
      return (UnableToCompleteException) e;
    } else if (e instanceof InternalCompilerException) {
      TreeLogger topBranch =
          logger.branch(TreeLogger.ERROR, "An internal compiler exception occurred", e);
      List<NodeInfo> nodeTrace = ((InternalCompilerException) e).getNodeTrace();
      for (NodeInfo nodeInfo : nodeTrace) {
        SourceInfo info = nodeInfo.getSourceInfo();
        String msg;
        if (info != null) {
          String fileName = info.getFileName();
          fileName = fileName.substring(fileName.lastIndexOf('/') + 1);
          fileName = fileName.substring(fileName.lastIndexOf('\\') + 1);
          msg = "at " + fileName + "(" + info.getStartLine() + "): ";
        } else {
          msg = "<no source info>: ";
        }

        String description = nodeInfo.getDescription();
        if (description != null) {
          msg += description;
        } else {
          msg += "<no description available>";
        }
        TreeLogger nodeBranch = topBranch.branch(TreeLogger.ERROR, msg, null);
        String className = nodeInfo.getClassName();
        if (className != null) {
          nodeBranch.log(TreeLogger.INFO, className, null);
        }
      }
      return new UnableToCompleteException();
    } else if (e instanceof VirtualMachineError) {
      // Always rethrow VM errors (an attempt to wrap may fail).
      throw (VirtualMachineError) e;
    } else {
      logger.log(TreeLogger.ERROR, "Unexpected internal compiler error", e);
      return new UnableToCompleteException();
    }
  }

  /**
   * Provides meaningful error messages and hints for types that failed to compile or are otherwise
   * missing.
   */
  public static int logErrorTrace(TreeLogger logger, Type logLevel,
      CompilerContext compilerContext, List<CompilationUnit> units, boolean hint) {
    int errorCount = 0;
    for (CompilationUnit unit : units) {
      if (unit.isError()) {
        logErrorTrace(logger, logLevel, compilerContext, unit.getTypeName(), hint);
        errorCount++;

        if (logger.isLoggable(TreeLogger.INFO) && unit instanceof GeneratedCompilationUnit) {
          CompilationProblemReporter.maybeDumpSource(logger,
              ((GeneratedCompilationUnit) unit).getSource(), unit.getTypeName());
        }
      }
    }
    return errorCount++;
  }

  /**
   * Provides a meaning error message and hints for a type that failed to compile or is otherwise
   * missing.
   */
  public static void logErrorTrace(TreeLogger logger, Type logLevel,
      CompilerContext compilerContext, String typeSourceName, boolean hint) {
    TreeLogger branch = logger.branch(TreeLogger.TRACE,
        "Tracing compile failure path for type '" + typeSourceName + "'");
    if (logErrorChain(branch, logLevel, typeSourceName,
        compilerContext.getCompilationErrorsIndex())) {
      return;
    }

    if (hint) {
      logHints(logger, typeSourceName);
    }
  }

  public static int logWarnings(TreeLogger logger, Type logLevelForWarnings,
      List<CompilationUnit> units) {
    int warningCount = 0;
    for (CompilationUnit unit : units) {
      if (CompilationProblemReporter.logWarnings(logger, logLevelForWarnings, unit)) {
        warningCount++;
      }
    }
    return warningCount++;
  }

  /**
   * Logs errors to the console.
   *
   * @param logger logger for reporting errors to the console
   * @param unit Compilation unit that may have errors
   * @param suppressErrors Controls he log level for logging errors. If <code>false</code> is passed,
   *          compilation errors are logged at TreeLogger.ERROR and warnings logged at
   *          TreeLogger.WARN. If <code>true</code> is passed, compilation errors are logged at
   *          TreeLogger.TRACE and TreeLogger.DEBUG.
   * @return <code>true</code> if an error was logged.
   */
  public static boolean reportErrors(TreeLogger logger, CompilationUnit unit,
      boolean suppressErrors) {
    CategorizedProblem[] problems = unit.getProblems();
    if (problems == null || problems.length == 0) {
      return false;
    }
    String fileName = unit.getResourceLocation();
    boolean isError = unit.isError();
    TreeLogger.Type warnLogLevel;
    TreeLogger.Type errorLogLevel;
    if (suppressErrors) {
      errorLogLevel = TreeLogger.TRACE;
      warnLogLevel = TreeLogger.DEBUG;
    } else {
      errorLogLevel = TreeLogger.ERROR;
      warnLogLevel = TreeLogger.WARN;
    }

    TreeLogger branch = null;
    // Log the errors and GWT warnings.
    for (CategorizedProblem problem : problems) {
      TreeLogger.Type logLevel;
      if (problem.isError()) {
        // Log errors.
        logLevel = errorLogLevel;
        // Only log GWT-specific warnings.
      } else if (problem.isWarning() && problem instanceof GWTProblem) {
        logLevel = warnLogLevel;
      } else {
        // Ignore all other problems.
        continue;
      }

      HelpInfo helpInfo = null;
      if (problem instanceof GWTProblem) {
        GWTProblem gwtProblem = (GWTProblem) problem;
        helpInfo = gwtProblem.getHelpInfo();
      }
      if (branch == null) {
        Type branchType = isError ? errorLogLevel : warnLogLevel;
        String branchString = isError ? "Errors" : "Warnings";
        branch = logger.branch(branchType, branchString + " in '" + fileName + "'", null);
      }
      branch.log(logLevel, toMessageWithLineNumber(problem), null, helpInfo);
    }

    if (branch != null && branch.isLoggable(TreeLogger.INFO)) {
      if (unit instanceof GeneratedCompilationUnit) {
        GeneratedCompilationUnit generatedUnit = (GeneratedCompilationUnit) unit;
        CompilationProblemReporter.maybeDumpSource(branch, generatedUnit.getSource(), unit
            .getTypeName());
      }
    }
    return branch != null;
  }

  private static void addUnitToVisit(CompilationErrorsIndex compilationErrorsIndex,
      String typeSourceName, Queue<String> toVisit, Set<String> visited) {
    if (compilationErrorsIndex.hasCompileErrors(typeSourceName)) {
      if (!visited.contains(typeSourceName)) {
        toVisit.add(typeSourceName);
        visited.add(typeSourceName);
      }
    }
  }

  /**
   * Returns readable compilation error messages for a compilation unit.
   * <p>
   * Should only be run on CompilationUnits that actually have problems.
   */
  private static List<String> formatErrors(CompilationUnit unit) {
    CategorizedProblem[] problems = unit.getProblems();
    assert problems != null && problems.length > 0;

    List<String> errorMessages = Lists.newArrayList();
    for (CategorizedProblem problem : problems) {
      if (!problem.isError()) {
        continue;
      }

      errorMessages.add(toMessageWithLineNumber(problem));
    }

    return errorMessages;
  }

  private static boolean hasWarnings(CompilationUnit unit) {
    CategorizedProblem[] problems = unit.getProblems();
    if (problems == null || problems.length == 0) {
      return false;
    }
    for (CategorizedProblem problem : problems) {
      if (problem.isWarning() && problem instanceof GWTProblem) {
        return true;
      }
    }
    return false;
  }

  private static boolean logErrorChain(TreeLogger logger, Type logLevel,
      String typeSourceName, CompilationErrorsIndex compilationErrorsIndex) {
    final Set<String> visited = new HashSet<String>();
    final Queue<String> toVisit = new LinkedList<String>();

    /*
     * Traverses CompilationUnits enqueued in toVisit(), calling {@link
     * #addUnitsToVisit(String)} as it encounters dependencies on the node. Each
     * CompilationUnit is visited only once, and only if it is reachable via the
     * {@link Dependencies} graph.
     */
    addUnitToVisit(compilationErrorsIndex, typeSourceName, toVisit, visited);

    while (!toVisit.isEmpty()) {
      String dependentTypeSourceName = toVisit.remove();

      Set<String> compileErrors = compilationErrorsIndex.getCompileErrors(dependentTypeSourceName);
      TreeLogger branch = logger.branch(logLevel,
          "Errors in '" + compilationErrorsIndex.getFileName(dependentTypeSourceName) + "'");
      for (String compileError : compileErrors) {
        branch.log(logLevel, compileError);
      }

      Set<String> typeReferences =
          compilationErrorsIndex.getTypeReferences(dependentTypeSourceName);
      if (typeReferences != null) {
        for (String typeReference : typeReferences) {
          addUnitToVisit(compilationErrorsIndex, typeReference, toVisit, visited);
        }
      }
    }
    logger.log(TreeLogger.DEBUG, "Checked " + visited.size() + " dependencies for errors.");
    return visited.size() > 1;
  }

  private static void logHints(TreeLogger logger, String typeSourceName) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();

    URL sourceURL = Util.findSourceInClassPath(cl, typeSourceName);
    if (sourceURL != null) {
      if (typeSourceName.indexOf(".client.") != -1) {
        Messages.HINT_CHECK_MODULE_INHERITANCE.log(logger, null);
      } else {
        Messages.HINT_CHECK_MODULE_NONCLIENT_SOURCE_DECL.log(logger, null);
      }
    } else if (!typeSourceName.equals("java.lang.Object")) {
      Messages.HINT_CHECK_TYPENAME.log(logger, typeSourceName, null);
      Messages.HINT_CHECK_CLASSPATH_SOURCE_ENTRIES.log(logger, null);
    }

    /*
     * For missing JRE emulated classes (e.g. Object), or the main GWT libraries, there are special
     * warnings.
     */
    if (typeSourceName.indexOf("java.lang.") == 0
        || typeSourceName.indexOf("com.google.gwt.core.") == 0) {
      Messages.HINT_CHECK_INHERIT_CORE.log(logger, null);
    } else if (typeSourceName.indexOf("com.google.gwt.user.") == 0) {
      Messages.HINT_CHECK_INHERIT_USER.log(logger, null);
    }
  }

  private static boolean logWarnings(TreeLogger logger, TreeLogger.Type logLevel,
      CompilationUnit unit) {
    if (!hasWarnings(unit)) {
      return false;
    }

    TreeLogger branch =
        logger.branch(logLevel, "Warnings in '" + unit.getResourceLocation() + "'", null);
    for (CategorizedProblem problem : unit.getProblems()) {
      if (!problem.isWarning() || !(problem instanceof GWTProblem)) {
        continue;
      }

      branch.log(logLevel, toMessageWithLineNumber(problem), null,
          ((GWTProblem) problem).getHelpInfo());
    }

    if (branch.isLoggable(TreeLogger.INFO) && unit instanceof GeneratedCompilationUnit) {
      CompilationProblemReporter.maybeDumpSource(branch,
          ((GeneratedCompilationUnit) unit).getSource(), unit.getTypeName());
    }
    return true;
  }

  /**
   * Give the developer a chance to see the in-memory source that failed.
   */
  private static void maybeDumpSource(TreeLogger logger, String source, String typeName) {
    File tmpSrc;
    Throwable caught = null;
    try {
      // The tempFile prefix must be at least 3 characters
      while (typeName.length() < 3) {
        typeName = "_" + typeName;
      }
      tmpSrc = File.createTempFile(typeName, ".java");
      Util.writeStringAsFile(tmpSrc, source);
      String dumpPath = tmpSrc.getAbsolutePath();
      if (logger.isLoggable(TreeLogger.INFO)) {
        logger.log(TreeLogger.INFO, "See snapshot: " + dumpPath, null);
      }
      return;
    } catch (IOException e) {
      caught = e;
    }
    logger.log(TreeLogger.INFO, "Unable to dump source to disk", caught);
  }

  private static String toMessageWithLineNumber(CategorizedProblem problem) {
    int lineNumber = problem.getSourceLineNumber();
    return (lineNumber > 0 ? "Line " + lineNumber + ": " : "") + problem.getMessage();
  }
}