/*
 * 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.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
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.core.ext.typeinfo.TypeOracleException;
import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
import com.google.gwt.i18n.shared.GwtLocale;
import com.google.gwt.user.rebind.SourceWriter;

import java.util.Map;

/**
 * Creates the class implementation for a given resource bundle using the
 * standard <code>AbstractGeneratorClassCreator</code>.
 */
class ConstantsImplCreator extends AbstractLocalizableImplCreator {
  /**
   * Does a Map need to be generated in order to store complex results?
   */
  private boolean needCache = false;

  /**
   * Constructor for <code>ConstantsImplCreator</code>.
   * 
   * @param logger logger to print errors
   * @param writer <code>Writer</code> to print to
   * @param localizableClass class/interface to conform to
   * @param resourceList resource bundle used to generate the class
   * @param oracle types
   * @throws UnableToCompleteException
   */
  public ConstantsImplCreator(TreeLogger logger, SourceWriter writer,
      JClassType localizableClass, ResourceList resourceList, TypeOracle oracle)
      throws UnableToCompleteException {
    super(logger, writer, localizableClass, resourceList, true);
    try {
      JClassType stringClass = oracle.getType(String.class.getName());
      JClassType mapClass = oracle.getType(Map.class.getName());
      JType stringArrayClass = oracle.getArrayType(stringClass);
      JType intClass = oracle.parse(int.class.getName());
      JType doubleClass = oracle.parse(double.class.getName());
      JType floatClass = oracle.parse(float.class.getName());
      JType booleanClass = oracle.parse(boolean.class.getName());
      register(stringClass, new SimpleValueMethodCreator(this,
          SimpleValueMethodCreator.STRING));
      register(mapClass, new ConstantsMapMethodCreator(this));
      register(intClass, new SimpleValueMethodCreator(this,
          SimpleValueMethodCreator.INT));
      register(doubleClass, new SimpleValueMethodCreator(this,
          SimpleValueMethodCreator.DOUBLE));
      register(floatClass, new SimpleValueMethodCreator(this,
          SimpleValueMethodCreator.FLOAT));
      register(booleanClass, new SimpleValueMethodCreator(this,
          SimpleValueMethodCreator.BOOLEAN));

      register(stringArrayClass, new ConstantsStringArrayMethodCreator(this));
    } catch (NotFoundException e) {
      throw error(logger, e);
    } catch (TypeOracleException e) {
      throw error(logger, e);
    }
  }

  /**
   * Checks that the method has the right structure to implement
   * <code>Constant</code>.
   * 
   * @param method method to check
   */
  protected void checkConstantMethod(TreeLogger logger, JMethod method)
      throws UnableToCompleteException {
    if (method.getParameters().length > 0) {
      throw error(logger,
          "Methods in interfaces extending Constant must have no parameters");
    }
    checkReturnType(logger, method);
  }

  /**
   * @param logger
   * @param method
   * @throws UnableToCompleteException
   */
  protected void checkReturnType(TreeLogger logger, JMethod method)
      throws UnableToCompleteException {
    JType returnType = method.getReturnType();
    JPrimitiveType primitive = returnType.isPrimitive();
    if (primitive != null
        && (primitive == JPrimitiveType.BOOLEAN
            || primitive == JPrimitiveType.DOUBLE
            || primitive == JPrimitiveType.FLOAT || primitive == JPrimitiveType.INT)) {
      return;
    }
    JArrayType arrayType = returnType.isArray();
    if (arrayType != null) {
      String arrayComponent = arrayType.getComponentType().getQualifiedSourceName();
      if (!arrayComponent.equals("java.lang.String")) {
        throw error(logger,
            "Methods in interfaces extending Constant only support arrays of Strings");
      }
      return;
    }
    String returnTypeName = returnType.getQualifiedSourceName();
    if (returnTypeName.equals("java.lang.String")) {
      return;
    }
    if (returnTypeName.equals("java.util.Map")) {
      JParameterizedType paramType = returnType.isParameterized();
      if (paramType != null) {
        JClassType[] typeArgs = paramType.getTypeArgs();
        if (typeArgs.length != 2
            || !typeArgs[0].getQualifiedSourceName().equals("java.lang.String")
            || !typeArgs[1].getQualifiedSourceName().equals("java.lang.String")) {
          throw error(logger,
              "Map Methods in interfaces extending Constant must be raw or <String, String>");
        }
      }
      return;
    }
    throw error(logger,
        "Methods in interfaces extending Constant must have a return type of "
            + "String/int/float/boolean/double/String[]/Map");
  }

  @Override
  protected void classEpilog() {
    if (isNeedCache()) {
      getWriter().println("java.util.Map cache = new java.util.HashMap();");
    }
  }

  /**
   * Create the method body associated with the given method. Arguments are
   * arg0...argN.
   */
  @Override
  protected void emitMethodBody(TreeLogger logger, JMethod method,
      GwtLocale locale) throws UnableToCompleteException {
    checkConstantMethod(logger, method);
    delegateToCreator(logger, method, locale);
  }

  boolean isNeedCache() {
    return needCache;
  }

  void setNeedCache(boolean needCache) {
    this.needCache = needCache;
  }
}