/*
 * Copyright 2010 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.requestfactory.rebind;

import com.google.gwt.core.ext.Generator;
import com.google.gwt.core.ext.GeneratorContext;
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.JField;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
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.event.shared.HandlerManager;
import com.google.gwt.requestfactory.client.impl.AbstractBigDecimalRequest;
import com.google.gwt.requestfactory.client.impl.AbstractBigIntegerRequest;
import com.google.gwt.requestfactory.client.impl.AbstractBooleanRequest;
import com.google.gwt.requestfactory.client.impl.AbstractByteRequest;
import com.google.gwt.requestfactory.client.impl.AbstractCharacterRequest;
import com.google.gwt.requestfactory.client.impl.AbstractDateRequest;
import com.google.gwt.requestfactory.client.impl.AbstractDoubleRequest;
import com.google.gwt.requestfactory.client.impl.AbstractEnumRequest;
import com.google.gwt.requestfactory.client.impl.AbstractFloatRequest;
import com.google.gwt.requestfactory.client.impl.AbstractIntegerRequest;
import com.google.gwt.requestfactory.client.impl.AbstractJsonListRequest;
import com.google.gwt.requestfactory.client.impl.AbstractJsonObjectRequest;
import com.google.gwt.requestfactory.client.impl.AbstractLongRequest;
import com.google.gwt.requestfactory.client.impl.AbstractShortRequest;
import com.google.gwt.requestfactory.client.impl.AbstractStringRequest;
import com.google.gwt.requestfactory.client.impl.AbstractVoidRequest;
import com.google.gwt.requestfactory.client.impl.RecordImpl;
import com.google.gwt.requestfactory.client.impl.RecordJsoImpl;
import com.google.gwt.requestfactory.client.impl.RecordSchema;
import com.google.gwt.requestfactory.client.impl.RecordToTypeMap;
import com.google.gwt.requestfactory.client.impl.RequestFactoryJsonImpl;
import com.google.gwt.requestfactory.server.ReflectionBasedOperationRegistry;
import com.google.gwt.requestfactory.shared.RecordListRequest;
import com.google.gwt.requestfactory.shared.RecordRequest;
import com.google.gwt.requestfactory.shared.RequestData;
import com.google.gwt.requestfactory.shared.RequestFactory;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
import com.google.gwt.valuestore.shared.Property;
import com.google.gwt.valuestore.shared.Record;
import com.google.gwt.valuestore.shared.RecordChangedEvent;
import com.google.gwt.valuestore.shared.WriteOperation;

import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

/**
 * <p> <span style="color:red">Experimental API: This class is still under rapid
 * development, and is very likely to be deleted. Use it at your own risk.
 * </span> </p> Generates implementations of {@link com.google.gwt.requestfactory.shared.RequestFactory
 * RequestFactory} and its nested interfaces.
 */
public class RequestFactoryGenerator extends Generator {

  private final Set<JClassType> generatedRecordTypes
      = new HashSet<JClassType>();

  @Override
  public String generate(TreeLogger logger, GeneratorContext generatorContext,
      String interfaceName) throws UnableToCompleteException {
    // The TypeOracle knows about all types in the type system
    TypeOracle typeOracle = generatorContext.getTypeOracle();

    // Get a reference to the type that the generator should implement
    JClassType interfaceType = typeOracle.findType(interfaceName);

    // Ensure that the requested type exists
    if (interfaceType == null) {
      logger.log(TreeLogger.ERROR,
          "Could not find requested typeName: " + interfaceName);
      throw new UnableToCompleteException();
    }
    if (interfaceType.isInterface() == null) {
      // The incoming type wasn't a plain interface, we don't support
      // abstract base classes
      logger.log(TreeLogger.ERROR,
          interfaceType.getQualifiedSourceName() + " is not an interface.",
          null);
      throw new UnableToCompleteException();
    }

    String packageName = interfaceType.getPackage().getName();

    // the replace protects against inner classes
    String implName = interfaceType.getName().replace('.', '_') + "Impl";
    PrintWriter out = generatorContext.tryCreate(logger, packageName, implName);

    // If an implementation already exists, we don't need to do any work
    if (out != null) {
      generateOnce(typeOracle.findType(RequestFactory.class.getCanonicalName()),
          logger, generatorContext, out, interfaceType, packageName, implName);
    }

    return packageName + "." + implName;
  }

  private String asInnerImplClass(String className, JClassType outerClassName) {
    className = outerClassName.getQualifiedSourceName() + "Impl." + className;
    return className;
  }

  private String capitalize(String name) {
    return name.substring(0, 1).toUpperCase() + name.substring(1);
  }

  private void ensureRecordType(TreeLogger logger,
      GeneratorContext generatorContext, String packageName,
      JClassType publicRecordType) throws UnableToCompleteException {
    TypeOracle typeOracle = generatorContext.getTypeOracle();

    if (!publicRecordType.isAssignableTo(typeOracle.findType(Record.class.getName()))) {
      return;
    }

    if (generatedRecordTypes.contains(publicRecordType)) {
      return;
    }

    String recordImplTypeName = publicRecordType.getName() + "Impl";
    PrintWriter pw = generatorContext.tryCreate(logger, packageName,
        recordImplTypeName);

    Set<JClassType> transitiveDeps = new LinkedHashSet<JClassType>();

    if (pw != null) {
      logger = logger.branch(TreeLogger.DEBUG, "Generating "
          + publicRecordType.getName());

      ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory(
          packageName, recordImplTypeName);

      String eventTypeName = publicRecordType.getName() + "Changed";
      JClassType eventType = typeOracle.findType(packageName, eventTypeName);
      if (eventType == null) {
        logger.log(TreeLogger.ERROR,
            String.format("Cannot find %s implementation %s.%s",
                RecordChangedEvent.class.getName(), packageName,
                eventTypeName));
        throw new UnableToCompleteException();
      }

      f.addImport(AbstractJsonListRequest.class.getName());
      f.addImport(AbstractJsonObjectRequest.class.getName());
      f.addImport(RequestFactoryJsonImpl.class.getName());
      f.addImport(Property.class.getName());
      f.addImport(Record.class.getName());
      f.addImport(RecordImpl.class.getName());
      f.addImport(RecordJsoImpl.class.getName());
      f.addImport(RecordSchema.class.getName());
      f.addImport(WriteOperation.class.getName().replace("$", "."));

      f.addImport(Collections.class.getName());
      f.addImport(HashSet.class.getName());
      f.addImport(Set.class.getName());
      f.addImport(Map.class.getName());
      f.addImport(HashMap.class.getName());

      f.setSuperclass(RecordImpl.class.getSimpleName());
      f.addImplementedInterface(publicRecordType.getName());

      SourceWriter sw = f.createSourceWriter(generatorContext, pw);
      sw.println();

      JClassType propertyType = printSchema(typeOracle, publicRecordType,
          recordImplTypeName, eventType, sw);

      sw.println();
      String simpleImplName = publicRecordType.getSimpleSourceName() + "Impl";
      printRequestImplClass(sw, publicRecordType, simpleImplName, true);
      printRequestImplClass(sw, publicRecordType, simpleImplName, false);

      sw.println();
      sw.println(String.format(
          "public static final RecordSchema<%s> SCHEMA = new MySchema();",
          recordImplTypeName));

      sw.println();
      sw.println(String.format("private %s(RecordJsoImpl jso, boolean isFuture) {",
          recordImplTypeName));
      sw.indent();
      sw.println("super(jso, isFuture);");
      sw.outdent();
      sw.println("}");

      // getter methods
      for (JField field : publicRecordType.getFields()) {
        JType fieldType = field.getType();
        if (propertyType.getErasedType() == fieldType.getErasedType()) {
          JParameterizedType parameterized = fieldType.isParameterized();
          if (parameterized == null) {
            logger.log(TreeLogger.ERROR,
                fieldType + " must have its param type set.");
            throw new UnableToCompleteException();
          }
          JClassType returnType = parameterized.getTypeArgs()[0];
          sw.println();
          sw.println(String.format("public %s get%s() {",
              returnType.getQualifiedSourceName(),
              capitalize(field.getName())));
          sw.indent();
          sw.println(String.format("return get(%s);", field.getName()));
          sw.outdent();
          sw.println("}");
          /*
           * Because a Proxy A may relate to B which relates to C, we need to
           * ensure transitively.
           */
          if (isRecordType(typeOracle, returnType)) {
            transitiveDeps.add(returnType);
          }
        }
      }

      // setter methods
      for (JField field : publicRecordType.getFields()) {
        JType fieldType = field.getType();
        if (propertyType.getErasedType() == fieldType.getErasedType()) {
          JParameterizedType parameterized = fieldType.isParameterized();
          if (parameterized == null) {
            logger.log(TreeLogger.ERROR, fieldType
                + " must have its param type set.");
            throw new UnableToCompleteException();
          }
          JClassType returnType = parameterized.getTypeArgs()[0];
          sw.println();
          String varName = field.getName();
          sw.println(String.format("public void set%s(%s %s) {",
              capitalize(field.getName()), returnType.getQualifiedSourceName(),
              varName));
          sw.indent();
          sw.println(String.format("set(this.%s, this, %s);", field.getName(), varName));
          sw.outdent();
          sw.println("}");
        }
      }

      sw.outdent();
      sw.println("}");
      generatorContext.commit(logger, pw);
    }

    generatedRecordTypes.add(publicRecordType);
    // ensure generatation of transitive dependencies
    for (JClassType type : transitiveDeps) {
      ensureRecordType(logger, generatorContext, type.getPackage().getName(),
          type);
    }
  }

  private void generateOnce(JClassType requestFactoryType, TreeLogger logger,
      GeneratorContext generatorContext, PrintWriter out,
      JClassType interfaceType, String packageName, String implName)
      throws UnableToCompleteException {

    logger = logger.branch(TreeLogger.DEBUG,
        String.format("Generating implementation of %s",
            interfaceType.getName()));

    ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory(
        packageName, implName);
    f.addImport(HandlerManager.class.getName());
    f.addImport(RequestFactoryJsonImpl.class.getName());
    f.addImport(interfaceType.getQualifiedSourceName());
    f.addImport(RecordToTypeMap.class.getName());
    f.addImport(Record.class.getName());
    f.addImport(RecordSchema.class.getName());
    f.addImplementedInterface(interfaceType.getName());
    f.setSuperclass(RequestFactoryJsonImpl.class.getSimpleName());

    SourceWriter sw = f.createSourceWriter(generatorContext, out);
    sw.println();

    // Find the requestSelector methods
    // TODO allow getRequest type methods to live directly on the factory, w/o
    // requiring a selector to get to them
    // TODO rename variable this requestBuilders, holding off to avoid merge
    // hell
    Set<JMethod> requestSelectors = new LinkedHashSet<JMethod>();
    for (JMethod method : interfaceType.getOverridableMethods()) {
      if (method.getEnclosingType().equals(requestFactoryType)) {
        continue;
      }
      JType returnType = method.getReturnType();
      if (null == returnType) {
        logger.log(TreeLogger.ERROR, String.format(
            "Illegal return type for %s. Methods of %s must return interfaces, found void",
            method.getName(), interfaceType.getName()));
        throw new UnableToCompleteException();
      }
      JClassType asInterface = returnType.isInterface();
      if (null == asInterface) {
        logger.log(TreeLogger.ERROR, String.format(
            "Illegal return type for %s. Methods of %s must return interfaces",
            method.getName(), interfaceType.getName()));
        throw new UnableToCompleteException();
      }
      requestSelectors.add(method);
    }

    // In addition to the request selectors in the generated interface, there
    // are a few which are in RequestFactory which also need to have
    // implementations generated. Hard coding the addition of these here for now
    JClassType t = generatorContext.getTypeOracle().findType(
        RequestFactory.class.getName());
    try {
      requestSelectors.add(t.getMethod("loggingRequest", new JType[0]));
    } catch (NotFoundException e) {
      e.printStackTrace();
    }

    JClassType recordToTypeInterface = generatorContext.getTypeOracle().findType(RecordToTypeMap.class.getName());
    // TODO: note, this seems like a bug. What if you have 2 RequestFactories?
    String recordToTypeMapName = recordToTypeInterface.getName() + "Impl";

    // write create(Class)
    sw.println("public " + Record.class.getName() + " create(Class token) {");
    sw.indent();
    sw.println("return create(token, new " + recordToTypeMapName + "());");
    sw.outdent();
    sw.println("}");
    sw.println();

    // write getClass(String)
    sw.println("public Class<? extends " + Record.class.getName() + "> getClass(String token) {");
    sw.indent();
    sw.println("return getClass(token, new " + recordToTypeMapName + "());");
    sw.outdent();
    sw.println("}");
    sw.println();

    // write getProxy(String)
    sw.println("public " + Record.class.getName() + " getProxy(String token) {");
    sw.indent();
    sw.println("return getProxy(token, new " + recordToTypeMapName + "());");
    sw.outdent();
    sw.println("}");
    sw.println();

    // write getToken(Record)
    sw.println("public String getToken(Record record) {");
    sw.indent();
    sw.println("return getToken(record, new " + recordToTypeMapName + "());");
    sw.outdent();
    sw.println("}");
    sw.println();

    // write getToken(Class)
    sw.println("public String getToken(Class clazz) {");
    sw.indent();
    sw.println("return new " + recordToTypeMapName + "().getClassToken(clazz);");
    sw.outdent();
    sw.println("}");
    sw.println();

    sw.println(
           "public RecordSchema<? extends Record> getSchema(String schemaToken) {");
    sw.indent();
    sw.println("return new " + recordToTypeMapName + "().getType(schemaToken);");
    sw.outdent();
    sw.println("}");

    // write a method for each request builder and generate it
    for (JMethod requestSelector : requestSelectors) {
      String returnTypeName = requestSelector.getReturnType().getQualifiedSourceName();
      String nestedImplName =
          capitalize(requestSelector.getName().replace('.', '_')) + "Impl";
      String nestedImplPackage = generatorContext.getTypeOracle().findType(
          returnTypeName).getPackage().getName();

      sw.println("public " + returnTypeName + " " + requestSelector.getName()
          + "() {");
      sw.indent();
      sw.println(
          "return new " + nestedImplPackage + "." + nestedImplName + "(this);");
      sw.outdent();
      sw.println("}");
      sw.println();

      PrintWriter pw = generatorContext.tryCreate(logger, nestedImplPackage,
          nestedImplName);
      if (pw != null) {
        generateRequestSelectorImplementation(logger, generatorContext, pw,
            requestSelector, interfaceType, nestedImplPackage, nestedImplName);
      }
    }

    // close the class
    sw.outdent();
    sw.println("}");

    // generate the mapping type implementation
    PrintWriter pw = generatorContext.tryCreate(logger, packageName,
        recordToTypeMapName);
    if (pw != null) {
      generateRecordToTypeMap(logger, generatorContext, pw,
          recordToTypeInterface, packageName, recordToTypeMapName);
    }
    generatorContext.commit(logger, out);
  }

  private void generateRecordToTypeMap(TreeLogger logger,
      GeneratorContext generatorContext, PrintWriter out,
      JClassType interfaceType, String packageName, String implName) {
    logger = logger.branch(TreeLogger.DEBUG,
        String.format("Generating implementation of %s",
            interfaceType.getName()));

    ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory(
        packageName, implName);
    f.addImport(interfaceType.getQualifiedSourceName());
    f.addImport(Record.class.getName());
    f.addImport(RecordSchema.class.getName());
    f.addImport(interfaceType.getQualifiedSourceName());
    f.addImplementedInterface(interfaceType.getName());

    f.addImplementedInterface(interfaceType.getName());

    SourceWriter sw = f.createSourceWriter(generatorContext, out);
    sw.println();

    sw.println("public <R extends Record> RecordSchema<R> getType(Class<R> recordClass) {");
    sw.indent();
    for (JClassType publicRecordType : generatedRecordTypes) {
      String qualifiedSourceName = publicRecordType.getQualifiedSourceName();
      sw.println("if (recordClass == " + qualifiedSourceName + ".class) {");
      sw.indent();
      sw.println("return (RecordSchema<R>) " + qualifiedSourceName + "Impl.SCHEMA;");
      sw.outdent();
      sw.println("}");
    }
    sw.println(
        "throw new IllegalArgumentException(\"Unknown recordClass \" + recordClass);");
    sw.indent();
    sw.outdent();
    sw.outdent();
    sw.println("}");

    sw.println("public RecordSchema<? extends Record> getType(String token) {");
    sw.indent();
    sw.println("String[] bits = token.split(\"-\");");
    for (JClassType publicRecordType : generatedRecordTypes) {
      String qualifiedSourceName = publicRecordType.getQualifiedSourceName();
      sw.println("if (bits[0].equals(\"" + qualifiedSourceName + "\")) {");
      sw.indent();
      sw.println("return " + qualifiedSourceName + "Impl.SCHEMA;");
      sw.outdent();
      sw.println("}");
    }
    sw.println("throw new IllegalArgumentException(\"Unknown string token: \" + token);");
    sw.outdent();
    sw.println("}");

    sw.println("public String getClassToken(Class<?> recordClass) {");
    sw.indent();
    for (JClassType publicRecordType : generatedRecordTypes) {
      String qualifiedSourceName = publicRecordType.getQualifiedSourceName();
      sw.println("if (recordClass == " + qualifiedSourceName + ".class) {");
      sw.indent();
      sw.println("return \"" + qualifiedSourceName + "\";");
      sw.outdent();
      sw.println("}");
    }
    sw.println(
        "throw new IllegalArgumentException(\"Unknown recordClass \" + recordClass);");
    sw.indent();
    sw.outdent();
    sw.outdent();
    sw.println("}");


    sw.outdent();
    sw.println("}");
    sw.println();

    generatorContext.commit(logger, out);
  }

  private void generateRequestSelectorImplementation(TreeLogger logger,
      GeneratorContext generatorContext, PrintWriter out,
      JMethod selectorMethod, JClassType mainType, String packageName,
      String implName) throws UnableToCompleteException {
    JClassType selectorInterface = selectorMethod.getReturnType().isInterface();
    logger = logger.branch(TreeLogger.DEBUG,
        String.format("Generating implementation of %s",
            selectorInterface.getName()));

    ClassSourceFileComposerFactory f = new ClassSourceFileComposerFactory(
        packageName, implName);
    f.addImport(RequestData.class.getName());
    f.addImport(mainType.getQualifiedSourceName() + "Impl");
    f.addImplementedInterface(selectorInterface.getQualifiedSourceName());

    SourceWriter sw = f.createSourceWriter(generatorContext, out);
    sw.println();

    sw.println("private final " + mainType.getName() + "Impl factory;");
    sw.println();
    // constructor for the class.
    sw.println(
        "public " + implName + "(" + mainType.getName() + "Impl factory) {");
    sw.indent();
    sw.println("this.factory = factory;");
    sw.outdent();
    sw.println("}");
    sw.println();

    // write each method.
    for (JMethod method : selectorInterface.getOverridableMethods()) {
      JClassType returnType = method.getReturnType().isParameterized().getTypeArgs()[0];

      ensureRecordType(logger, generatorContext,
          returnType.getPackage().getName(), returnType);

      String operationName = selectorInterface.getQualifiedBinaryName()
          + ReflectionBasedOperationRegistry.SCOPE_SEPARATOR + method.getName();

      JClassType requestType = method.getReturnType().isClassOrInterface();
      String requestClassName = null;

      TypeOracle typeOracle = generatorContext.getTypeOracle();
      String enumArgument = "";
      // TODO: refactor this into some kind of extensible map lookup
      if (isRecordListRequest(typeOracle, requestType)) {
        requestClassName = asInnerImplClass("ListRequestImpl", returnType);
      } else if (isRecordRequest(typeOracle, requestType)) {
        requestClassName = asInnerImplClass("ObjectRequestImpl", returnType);
      } else if (isStringRequest(typeOracle, requestType)) {
        requestClassName = AbstractStringRequest.class.getName();
      } else if (isLongRequest(typeOracle, requestType)) {
        requestClassName = AbstractLongRequest.class.getName();
      } else if (isIntegerRequest(typeOracle, requestType)) {
        requestClassName = AbstractIntegerRequest.class.getName();
      } else if (isDoubleRequest(typeOracle, requestType)) {
        requestClassName = AbstractDoubleRequest.class.getName();
      } else if (isByteRequest(typeOracle, requestType)) {
        requestClassName = AbstractByteRequest.class.getName();
      } else if (isBooleanRequest(typeOracle, requestType)) {
        requestClassName = AbstractBooleanRequest.class.getName();
      } else if (isShortRequest(typeOracle, requestType)) {
        requestClassName = AbstractShortRequest.class.getName();
      } else if (isFloatRequest(typeOracle, requestType)) {
        requestClassName = AbstractFloatRequest.class.getName();
      } else if (isCharacterRequest(typeOracle, requestType)) {
        requestClassName = AbstractCharacterRequest.class.getName();
      } else if (isDateRequest(typeOracle, requestType)) {
        requestClassName = AbstractDateRequest.class.getName();
      } else if (isBigDecimalRequest(typeOracle, requestType)) {
        requestClassName = AbstractBigDecimalRequest.class.getName();
      } else if (isBigIntegerRequest(typeOracle, requestType)) {
        requestClassName = AbstractBigIntegerRequest.class.getName();
      } else if (isEnumRequest(typeOracle, requestType)) {
        requestClassName = AbstractEnumRequest.class.getName();
        enumArgument = ", " + requestType.isParameterized().getTypeArgs()[0]
            + ".values()";
      } else if (isVoidRequest(typeOracle, requestType)) {
        requestClassName = AbstractVoidRequest.class.getName();
      } else {
        logger.log(TreeLogger.ERROR,
            "Return type " + requestType + " is not yet supported");
        throw new UnableToCompleteException();
      }

      sw.println(getMethodDeclaration(method) + " {");
      sw.indent();
      sw.println(
          "return new " + requestClassName + "(factory" + enumArgument + ") {");
      sw.indent();
      String requestDataName = RequestData.class.getSimpleName();
      sw.println("public " + requestDataName + " getRequestData() {");
      sw.indent();
      sw.println(
          "return new " + requestDataName + "(\"" + operationName + "\", "
              + getParametersAsString(method, typeOracle) + ","
              + "getPropertyRefs());");
      sw.outdent();
      sw.println("}");
      sw.outdent();
      sw.println("};");
      sw.outdent();
      sw.println("}");
    }

    sw.outdent();
    sw.println("}");
    generatorContext.commit(logger, out);
  }

  /**
   * This method is very similar to {@link com.google.gwt.core.ext.typeinfo.JMethod.getReadableDeclaration()}.
   * The only change is that each parameter is final.
   */
  private String getMethodDeclaration(JMethod method) {
    StringBuilder sb = new StringBuilder("public ");
    sb.append(method.getReturnType().getParameterizedQualifiedSourceName());
    sb.append(" ");
    sb.append(method.getName());
    sb.append("(");

    boolean needComma = false;
    for (JParameter param : method.getParameters()) {
      if (needComma) {
        sb.append(", ");
      } else {
        needComma = true;
      }
      sb.append("final "); // so that an anonymous class can refer it
      sb.append(param.getType().getParameterizedQualifiedSourceName());
      sb.append(" ");
      sb.append(param.getName());
    }
    sb.append(")");
    return sb.toString();
  }

  /**
   * Returns the string representation of the parameters to be passed to the
   * server side method.
   */
  private String getParametersAsString(JMethod method, TypeOracle typeOracle) {
    StringBuilder sb = new StringBuilder();
    for (JParameter parameter : method.getParameters()) {
      if (sb.length() > 0) {
        sb.append(", ");
      }
      JClassType classType = parameter.getType().isClassOrInterface();

      JType paramType = parameter.getType();
      boolean isRef =
          "com.google.gwt.valuestore.shared.PropertyReference".equals(
          paramType.getQualifiedBinaryName());
      JParameterizedType params = paramType.isParameterized();
      if (params != null) {
        classType = params.getTypeArgs()[0];
      }
      if (classType != null
          && classType.isAssignableTo(typeOracle.findType(Record.class.getName()))) {
        sb.append("((" + classType.getQualifiedBinaryName() + "Impl" + ")");
      }
      sb.append(parameter.getName());
      // TODO No. This defeats the entire purpose of PropertyReference. It's
      // supposed
      // to be dereferenced server side, not client side.
      if (isRef) {
        sb.append(".get()");
      }
      if (classType != null
          && classType.isAssignableTo(typeOracle.findType(Record.class.getName()))) {
        sb.append(").getUniqueId()");
      }
    }
    return "new Object[] {" + sb.toString() + "}";
  }

  private boolean isBigDecimalRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(BigDecimal.class.getName()));
  }

  private boolean isBigIntegerRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(BigInteger.class.getName()));
  }

  private boolean isBooleanRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Boolean.class.getName()));
  }

  private boolean isByteRequest(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Byte.class.getName()));
  }

  private boolean isCharacterRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Character.class.getName()));
  }

  private boolean isDateRequest(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Date.class.getName()));
  }

  private boolean isDoubleRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Double.class.getName()));
  }

  private boolean isEnumRequest(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Enum.class.getName()));
  }

  private boolean isFloatRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Float.class.getName()));
  }

  private boolean isIntegerRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Integer.class.getName()));
  }

  private boolean isLongRequest(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Long.class.getName()));
  }

  private boolean isRecordListRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isAssignableTo(typeOracle.findType(RecordListRequest.class.getName()));
  }

  private boolean isRecordRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isAssignableTo(typeOracle.findType(RecordRequest.class.getName()));
  }

  private boolean isRecordType(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isAssignableTo(typeOracle.findType(Record.class.getName()));
  }

  private boolean isShortRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Short.class.getName()));
  }

  private boolean isStringRequest(TypeOracle typeOracle,
      JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(String.class.getName()));
  }

  private boolean isVoidRequest(TypeOracle typeOracle, JClassType requestType) {
    return requestType.isParameterized().getTypeArgs()[0].isAssignableTo(typeOracle.findType(Void.class.getName()));
  }

  /**
   * Prints a ListRequestImpl or ObjectRequestImpl class.
   */
  private void printRequestImplClass(SourceWriter sw, JClassType returnType,
      String returnImplTypeName, boolean list) {

    String name = list ? "ListRequestImpl" : "ObjectRequestImpl";
    Class<?> superClass = list ? AbstractJsonListRequest.class
        : AbstractJsonObjectRequest.class;

    sw.println("public static abstract class " + name + " extends "
        + superClass.getSimpleName() + "<" + returnType.getName() + ", " + name
        + "> {");
    sw.println();
    sw.indent();

    sw.println(String.format("%s(%s factory) {", name,
        RequestFactoryJsonImpl.class.getSimpleName()));
    sw.indent();
    sw.println("super(" + returnImplTypeName + ".SCHEMA, factory);");
    sw.outdent();
    sw.println("}");
    sw.println();
    sw.println("@Override");
    sw.println("protected " + name + " getThis() {");
    sw.indent();
    sw.println("return this;");
    sw.outdent();
    sw.println("}");

    sw.outdent();
    sw.println("}");
    sw.println();
  }

  /**
   * @param typeOracle
   * @param publicRecordType
   * @param recordImplTypeName
   * @param eventType
   * @param sw
   * @return
   * @throws UnableToCompleteException
   */

  private JClassType printSchema(TypeOracle typeOracle,
      JClassType publicRecordType, String recordImplTypeName,
      JClassType eventType, SourceWriter sw) {
    sw.println(
        String.format("public static class MySchema extends RecordSchema<%s> {",
            recordImplTypeName));

    sw.indent();
    sw.println("private final Set<Property<?>> allProperties;");
    sw.println("{");

    sw.indent();
    sw.println("Set<Property<?>> set = new HashSet<Property<?>>();");
    sw.println("set.addAll(super.allProperties());");

    JClassType propertyType;
    try {
      propertyType = typeOracle.getType(Property.class.getName());
    } catch (NotFoundException e) {
      throw new RuntimeException(e);
    }

    for (JField field : publicRecordType.getFields()) {
      if (propertyType.getErasedType() == field.getType().getErasedType()) {
        sw.println(String.format("set.add(%s);", field.getName()));
      }
    }

    sw.println("allProperties = Collections.unmodifiableSet(set);");
    sw.outdent();
    sw.println("}");

    sw.println();
    sw.println("public Set<Property<?>> allProperties() {");
    sw.indent();
    sw.println("return allProperties;");
    sw.outdent();
    sw.println("}");

    sw.println();
    sw.println("public MySchema() {");
    sw.indent();
    sw.println("super(\"" + publicRecordType.getQualifiedSourceName() + "\");");
    sw.outdent();
    sw.println("}");

    sw.println();
    sw.println("@Override");
    sw.println(String.format("public %s create(RecordJsoImpl jso, boolean isFuture) {",
        recordImplTypeName));
    sw.indent();
    sw.println(String.format("return new %s(jso, isFuture);", recordImplTypeName));
    sw.outdent();
    sw.println("}");

    sw.println();
    sw.println("@Override");
    sw.println(String.format(
        "public %s createChangeEvent(Record record, WriteOperation writeOperation) {",
        eventType.getName()));
    sw.indent();
    sw.println(String.format("return new %s((%s) record, writeOperation);",
        eventType.getName(), publicRecordType.getName()));
    sw.outdent();
    sw.println("}");

    sw.println();
    sw.println("public Class getProxyClass() {");
    sw.indent();
    sw.println("return " + publicRecordType.getQualifiedSourceName() + ".class;"
        + " // special field");
    sw.outdent();
    sw.println("}");

    sw.outdent();
    sw.println("}");
    return propertyType;
  }
}