/*
 * 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.i18n.rebind;

import com.google.gwt.codegen.rebind.GwtCodeGenContext;
import com.google.gwt.codegen.server.CodeGenContext;
import com.google.gwt.codegen.server.CodeGenUtils;
import com.google.gwt.codegen.server.JavaSourceWriterBuilder;
import com.google.gwt.codegen.server.SourceWriter;
import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.Generator.RunsLocal;
import com.google.gwt.core.ext.GeneratorContext;
import com.google.gwt.core.ext.PropertyOracle;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.i18n.client.Constants;
import com.google.gwt.i18n.client.ConstantsWithLookup;
import com.google.gwt.i18n.client.LocaleInfo;
import com.google.gwt.i18n.client.Messages;
import com.google.gwt.i18n.shared.GwtLocale;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * Generator used to bind classes extending the <code>Localizable</code> and
 * <code>Constants</code> interfaces.
 */
@RunsLocal(requiresProperties = {"locale.queryparam", "locale", "runtime.locales", "locale.cookie"})
public class LocalizableGenerator extends Generator {

  /**
   * Comparator for methods - sorts first by visibility, then name, then number
   * of arguments, then argument names.
   */
  public class JMethodComparator implements Comparator<JMethod> {

    public int compare(JMethod a, JMethod b) {
      if (a.isPublic() != b.isPublic()) {
        return a.isPublic() ? -1 : 1;
      }
      if (a.isDefaultAccess() != b.isDefaultAccess()) {
        return a.isDefaultAccess() ? -1 : 1;
      }
      if (a.isProtected() != b.isProtected()) {
        return a.isProtected() ? -1 : 1;
      }
      int c = a.getName().compareTo(b.getName());
      if (c != 0) {
        return c;
      }
      JParameter[] aParams = a.getParameters();
      JParameter[] bParams = b.getParameters();
      c = aParams.length - bParams.length;
      if (c != 0) {
        return c;
      }
      for (int i = 0; i < aParams.length; ++i) {
        c = aParams[i].getName().compareTo(bParams[i].getName());
        if (c != 0) {
          return c;
        }
      }
      return 0;
    }
  }

  public static final String CONSTANTS_NAME = Constants.class.getName();

  public static final String CONSTANTS_WITH_LOOKUP_NAME = ConstantsWithLookup.class.getName();

  /**
    * Obsolete comment for GWT metadata - needs to be removed once all
    * references have been removed.
    */
  public static final String GWT_KEY = "gwt.key";

  public static final String MESSAGES_NAME = Messages.class.getName();

  private LocalizableLinkageCreator linkageCreator = new LocalizableLinkageCreator();

  /**
   * Generate an implementation for the given type.
   *
   * @param logger error logger
   * @param context generator context
   * @param typeName target type name
   * @return a fully-qualified classname of the generated implementation, or
   *     null to use the base class
   * @throws UnableToCompleteException
   */
  @Override
  public final String generate(TreeLogger logger, GeneratorContext context,
      String typeName) throws UnableToCompleteException {
    // Get the current locale
    PropertyOracle propertyOracle = context.getPropertyOracle();
    LocaleUtils localeUtils = LocaleUtils.getInstance(logger, propertyOracle,
        context);
    GwtLocale locale = localeUtils.getCompileLocale();
    return generate(logger, context, typeName, localeUtils, locale);
  }

  /**
   * Generate an implementation for a given type.
   *
   * @param logger
   * @param context
   * @param typeName
   * @param localeUtils
   * @param locale
   * @return a fully-qualified classname of the generated implementation, or
   *     null to use the base class
   * @throws UnableToCompleteException
   */
  public final String generate(TreeLogger logger, GeneratorContext context,
      String typeName, LocaleUtils localeUtils, GwtLocale locale) throws UnableToCompleteException {
    TypeOracle typeOracle = context.getTypeOracle();
    JClassType targetClass;
    try {
      targetClass = typeOracle.getType(typeName);
    } catch (NotFoundException e) {
      logger.log(TreeLogger.ERROR, "No such type", e);
      throw new UnableToCompleteException();
    }

    // Link current locale and interface type to correct implementation class.
    String generatedClass = AbstractLocalizableImplCreator.generateConstantOrMessageClass(
        logger, context, locale, targetClass);
    if (generatedClass != null) {
      return generatedClass;
    }

    // Now that we know it is a regular Localizable class, handle runtime
    // locales
    Set<GwtLocale> runtimeLocales = localeUtils.getRuntimeLocales();
    String returnedClass = linkageCreator.linkWithImplClass(logger, targetClass, locale);
    if (!runtimeLocales.isEmpty()) {
      Map<String, Set<GwtLocale>> localeMap = new TreeMap<String, Set<GwtLocale>>();
      Set<GwtLocale> localeSet = new TreeSet<GwtLocale>();
      localeSet.add(locale);
      localeMap.put(returnedClass, localeSet);
      for (GwtLocale rtLocale : runtimeLocales) {
        String rtClass = linkageCreator.linkWithImplClass(logger, targetClass, rtLocale);
        localeSet = localeMap.get(rtClass);
        if (localeSet == null) {
          localeSet = new TreeSet<GwtLocale>();
          localeMap.put(rtClass, localeSet);
        }
        localeSet.add(rtLocale);
      }
      if (localeMap.size() > 1) {
        CodeGenContext genCtx = new GwtCodeGenContext(logger, context);
        returnedClass = generateRuntimeSelection(genCtx, targetClass, returnedClass, locale,
            localeMap);
      }
    }

    return returnedClass;
  }

  /**
   * Generate a runtime-selection implementation of the target class if needed,
   * delegating all overridable methods to an instance chosen at runtime based
   * on the map of locales to implementing classes.
   *
   * @param ctx code generator context
   * @param targetClass class being GWT.create'd
   * @param defaultClass the default implementation to use
   * @param locale compile-time locale for this runtime selection
   * @param localeMap map of target class names to the set of locales that are
   *     mapped to that implementation (for deterministic code generation, both
   *     the map and set should be ordered)
   * @return fully qualified classname of the runtime selection implementation
   */
  // @VisibleForTesting
  String generateRuntimeSelection(CodeGenContext ctx, JClassType targetClass, String defaultClass,
      GwtLocale locale, Map<String, Set<GwtLocale>> localeMap) {
    String className = targetClass.getName().replace('.', '_') + '_' + locale.getAsString()
        + "_runtimeSelection";
    String pkgName = targetClass.getPackage().getName();
    JavaSourceWriterBuilder builder = ctx.addClass(pkgName, className);
    if (builder != null) {
      writeRuntimeSelection(builder, targetClass, defaultClass, locale, localeMap);
    }
    return pkgName + '.' + className;
  }

  /**
   * Generate a runtime-selection implementation of the target class, delegating
   * all overridable methods to an instance chosen at runtime based on the map
   * of locales to implementing classes.
   *
   * @param builder source writer builder
   * @param targetClass class being GWT.create'd
   * @param defaultClass the default implementation to use
   * @param locale compile-time locale for this runtime selection
   * @param localeMap map of target class names to the set of locales that are
   *     mapped to that implementation (for deterministic code generation, both
   *     the map and set should be ordered)
   */
  // @VisibleForTesting
  void writeRuntimeSelection(JavaSourceWriterBuilder builder, JClassType targetClass,
        String defaultClass, GwtLocale locale, Map<String, Set<GwtLocale>> localeMap) {
    boolean isInterface = targetClass.isInterface() != null;
    if (isInterface) {
      builder.addImplementedInterface(targetClass.getQualifiedSourceName());
    } else {
      builder.setSuperclass(targetClass.getQualifiedSourceName());
    }
    SourceWriter writer = builder.createSourceWriter();
    writer.println();
    writer.println("private " + targetClass.getQualifiedSourceName() + " instance;");
    for (JMethod method : collectOverridableMethods(targetClass)) {
      writer.println();
      if (!isInterface) {
        writer.println("@Override");
      }
      writer.println(method.getReadableDeclaration(false, true, true, true, true) + " {");
      writer.indent();
      writer.println("ensureInstance();");
      if (method.getReturnType() != JPrimitiveType.VOID) {
        writer.print("return ");
      }
      writer.print("instance." + method.getName() + '(');
      boolean first = true;
      for (JParameter param : method.getParameters()) {
        if (first) {
          first = false;
        } else {
          writer.print(", ");
        }
        writer.print(param.getName());
      }
      writer.println(");");
      writer.outdent();
      writer.println("}");
    }
    writer.println();
    writer.println("private void ensureInstance() {");
    writer.indent();
    writer.println("if (instance != null) {");
    writer.indentln("return;");
    writer.println("}");
    writer.println("String locale = " + LocaleInfo.class.getCanonicalName()
        + ".getCurrentLocale().getLocaleName();");
    String targetClassName = targetClass.getQualifiedSourceName() + '_' + locale.getAsString();
    for (Map.Entry<String, Set<GwtLocale>> entry : localeMap.entrySet()) {
      String implClassName = entry.getKey();
      if (defaultClass.equals(implClassName) || targetClassName.equals(implClassName)) {
        continue;
      }
      String prefix = "if (";
      for (GwtLocale match : entry.getValue()) {
        writer.print(prefix + CodeGenUtils.asStringLiteral(match.toString()) + ".equals(locale)");
        prefix = "\n    || ";
      }
      writer.println(") {");
      writer.indent();
      writer.println("instance = new " + implClassName + "();");
      writer.println("return;");
      writer.outdent();
      writer.println("}");
    }
    writer.println("instance = new " + defaultClass + "();");
    writer.outdent();
    writer.println("}");
    writer.close();
  }

  /**
   * @param targetClass
   * @return a set of overrideable methods, in the order they should appear in
   *     generated source
   */
  private TreeSet<JMethod> collectOverridableMethods(JClassType targetClass) {
    TreeSet<JMethod> overrides = new TreeSet<JMethod>(new JMethodComparator());
    Set<String> seenSignatures = new HashSet<String>();
    // collect methods from superclass until we get to object
    for (JClassType clazz = targetClass; clazz != null; clazz = clazz.getSuperclass()) {
      if ("java.lang.Object".equals(clazz.getQualifiedSourceName())) {
        break;
      }
      for (JMethod method : clazz.getMethods()) {
        String signature = getSignature(method);
        if (!seenSignatures.contains(signature)) {
          seenSignatures.add(signature);
          if (!method.isPrivate() && !method.isFinal() && !method.isStatic()) {
            overrides.add(method);
          }
        }
      }
    }
    // collect methods from superinterfaces until hitting Localizable
    ArrayList<JClassType> todo = new ArrayList<JClassType>();
    todo.addAll(Arrays.asList(targetClass.getImplementedInterfaces()));
    while (!todo.isEmpty()) {
      JClassType clazz = todo.remove(0);
      for (JMethod method : clazz.getMethods()) {
        String signature = getSignature(method);
        if (!seenSignatures.contains(signature)) {
          seenSignatures.add(signature);
          if (!method.isPrivate() && !method.isFinal() && !method.isStatic()) {
            overrides.add(method);
          }
        }
      }
      if (!"Localizable".equals(clazz.getSimpleSourceName())) {
        todo.addAll(Arrays.asList(clazz.getImplementedInterfaces()));
      }
    }
    return overrides;
  }

  /**
   * @param method
   * @return JNI signature of the method
   */
  private String getSignature(JMethod method) {
    StringBuilder buf = new StringBuilder();
    buf.append(method.getName()).append('(');
    for (JParameter param : method.getParameters()) {
      JType type = param.getType();
      buf.append(type.getJNISignature());
    }
    return buf.append(')').toString();
  }
}