/*
 * Copyright 2008 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.user.rebind.rpc;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.TreeLogger.Type;
import com.google.gwt.core.ext.typeinfo.JClassType;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * A collection of reported problems; these are accumulated during the
 * SerializableTypeOracleBuilder's isSerializable analysis, and what to do about
 * the problems is decided only later.
 */
public class ProblemReport {

  /**
   * Priority of problems. {@link #FATAL} problems will fail a build that would
   * otherwise have succeeded, for example because of a bad custom serializer
   * used only as a subclass of a superclass with other viable subtypes.
   * {@link #DEFAULT} problems might or might not be fatal, depending on overall
   * results accumulated later. {@link #AUXILIARY} problems are not fatal, and
   * often not even problems by themselves, but diagnostics related to default
   * problems (e.g. type filtration, which might suppress an
   * intended-to-serialize class).
   */
  public enum Priority {
    FATAL, DEFAULT, AUXILIARY
  }

  /**
   * An individual report, which may require multiple entries (expressed as logs
   * under a branchpoint), but relates to an individual issue.
   */
  public static class Problem {
    private String message;
    private List<String> childMessages;

    private Problem(String message, String[] children) {
      this.message = message;
      // most problems don't have sub-messages, so init at zero size
      childMessages = new ArrayList<String>(children.length);
      for (int i = 0; i < children.length; i++) {
        childMessages.add(children[i]);
      }
    }

    public void addChild(String message) {
      childMessages.add(message);
    }

    public String getPrimaryMessage() {
      return message;
    }

    public Iterable<String> getSubMessages() {
      return childMessages;
    }

    public boolean hasSubMessages() {
      return !childMessages.isEmpty();
    }
  }

  private Map<JClassType, List<Problem>> allProblems;
  private Map<JClassType, List<Problem>> auxiliaries;
  private Map<JClassType, List<Problem>> fatalProblems;
  private JClassType contextType;

  /**
   * Creates a new, empty, context-less ProblemReport.
   */
  public ProblemReport() {
    Comparator<JClassType> comparator = new Comparator<JClassType>() {
      public int compare(JClassType o1, JClassType o2) {
        assert o1 != null;
        assert o2 != null;
        return o1.getParameterizedQualifiedSourceName().compareTo(
            o2.getParameterizedQualifiedSourceName());
      }
    };
    allProblems = new TreeMap<JClassType, List<Problem>>(comparator);
    auxiliaries = new TreeMap<JClassType, List<Problem>>(comparator);
    fatalProblems = new TreeMap<JClassType, List<Problem>>(comparator);
    contextType = null;
  }

  /**
   * Adds a problem for a given type. This also sorts the problems into
   * collections by priority.
   * 
   * @param type the problematic type
   * @param message the description of the problem
   * @param priority priority of the problem.
   * @param extraLines additional continuation lines for the message, usually
   *          for additional explanations.
   */
  public Problem add(JClassType type, String message, Priority priority, String... extraLines) {
    String contextString = "";
    if (contextType != null) {
      contextString = " (reached via " + contextType.getParameterizedQualifiedSourceName() + ")";
    }
    message = message + contextString;
    Problem entry = new Problem(message, extraLines);
    if (priority == Priority.AUXILIARY) {
      addToMap(type, entry, auxiliaries);
      return entry;
    }

    // both FATAL and DEFAULT problems go in allProblems...
    addToMap(type, entry, allProblems);

    // only FATAL problems go in fatalProblems...
    if (priority == Priority.FATAL) {
      addToMap(type, entry, fatalProblems);
    }
    return entry;
  }

  public String getWorstMessageForType(JClassType type) {
    List<Problem> list = fatalProblems.get(type);
    if (list == null) {
      list = allProblems.get(type);
      if (list == null) {
        list = auxiliaries.get(type);
      }
    }
    if (list == null) {
      return null;
    }
    return list.get(0).getPrimaryMessage() + (list.size() > 1 ? ", etc." : "");
  }

  /**
   * Were any problems reported as "fatal"?
   */
  public boolean hasFatalProblems() {
    return !fatalProblems.isEmpty();
  }

  /**
   * Reports all problems to the logger supplied, at the log level supplied. The
   * problems are assured of being reported in lexographic order of type names.
   * 
   * @param logger logger to receive problem reports
   * @param problemLevel severity level at which to report problems.
   * @param auxLevel severity level at which to report any auxiliary messages.
   */
  public void report(TreeLogger logger, TreeLogger.Type problemLevel, TreeLogger.Type auxLevel) {
    doReport(logger, auxLevel, auxiliaries);
    doReport(logger, problemLevel, allProblems);
  }

  /**
   * Reports only urgent problems to the logger supplied, at the log level
   * supplied. The problems are assured of being reported in lexographic order
   * of type names.
   * 
   * @param logger logger to receive problem reports
   * @param level severity level at which to report problems.
   */
  public void reportFatalProblems(TreeLogger logger, TreeLogger.Type level) {
    doReport(logger, level, fatalProblems);
  }

  /**
   * Sets the context type currently being analyzed. Problems found will include
   * reference to this context, until reset with another call to this method.
   * Context may be canceled with a {@code null} value here.
   * 
   * @param newContext the type under analysis
   */
  public void setContextType(JClassType newContext) {
    contextType = newContext;
  }

  /**
   * Test accessor returning list of auxiliary "problems" logged against a given
   * type.
   * 
   * @param type type to fetch problems for
   * @return {@code null} if no auxiliaries were logged. Otherwise, a list of
   *         strings describing messages, including the context in which the
   *         problem was found.
   */
  List<Problem> getAuxiliaryMessagesForType(JClassType type) {
    List<Problem> list = auxiliaries.get(type);
    if (list == null) {
      list = new ArrayList<Problem>(0);
    }
    return list;
  }

  /**
   * Test accessor returning list of problems logged against a given type.
   * 
   * @param type type to fetch problems for
   * @return {@code null} if no problems were logged. Otherwise, a list of
   *         strings describing problems, including the context in which the
   *         problem was found.
   */
  List<Problem> getProblemsForType(JClassType type) {
    List<Problem> list = allProblems.get(type);
    if (list == null) {
      list = new ArrayList<Problem>(0);
    }
    return list;
  }

  /**
   * Adds an entry to one of the problem maps.
   * 
   * @param type the type to add
   * @param message the message to add for {@code type}
   * @param map the map to add to
   */
  private void addToMap(JClassType type, Problem problem, Map<JClassType, List<Problem>> map) {
    List<Problem> list = map.get(type);
    if (list == null) {
      list = new ArrayList<Problem>();
      map.put(type, list);
    }
    list.add(problem);
  }

  /**
   * Logs all of the problems from one of the problem maps.
   * 
   * @param logger the logger to log to
   * @param level the level for messages
   * @param problems the problems to log
   */
  private void doReport(TreeLogger logger, Type level, Map<JClassType, List<Problem>> problems) {
    if (!logger.isLoggable(level)) {
      return;
    }
    for (List<Problem> problemList : problems.values()) {
      for (Problem problem : problemList) {
        if (problem.hasSubMessages()) {
          TreeLogger sublogger = logger.branch(level, problem.getPrimaryMessage());
          for (String sub : problem.getSubMessages()) {
            sublogger.log(level, sub);
          }
        } else {
          logger.log(level, problem.getPrimaryMessage());
        }
      }
    }
  }
}