Copyright (c) 2012 LinkedIn Corp.

   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.

*/

* Generates Java request builders from Rest.li idl.

*

* @author Eran Leshem

*/

  private static class JavaBinding

  {

    /**

     * schemaClass provides the class from which the schema can be obtained

     * schemaClass may be different from valueClass if the actual schema is a typeref

     * in the case of a typeref, the TyperefInfo class cannot be a valueClass but is a schemaClass

     */

    private JClass schemaClass;

    /**

     * value class is used for method params and return types

     */

    private JClass valueClass;

  }

  private static final String GENERATOR_REST_GENERATE_DATATEMPLATES = "generator.rest.generate.datatemplates";

  private static final String GENERATOR_REST_GENERATE_RESTLI2 = "generator.rest.generate.restli2";

  private static final Logger log = LoggerFactory.getLogger(RestRequestBuilderGenerator.class);

  private static final String NAME = "name";

  private static final String NAMESPACE = "namespace";

  private static final String BUILDER = "Builder";

  private static final String BUILDERS = "Builders";

  private static final String REQUEST_BUILDER = "RequestBuilder";

  private static final String REQUEST_BUILDERS = "RequestBuilders";

  private static final RestSpecCodec _codec = new RestSpecCodec();

  private final JClass _voidClass = getCodeModel().ref(Void.class);

  private final JClass _fieldDefClass = getCodeModel().ref(FieldDef.class);

  private final JClass _resourceSpecClass = getCodeModel().ref(ResourceSpec.class);

  private final JClass _resourceSpecImplClass = getCodeModel().ref(ResourceSpecImpl.class);

  private final JClass _enumSetClass = getCodeModel().ref(EnumSet.class);

  private final JClass _resourceMethodClass = getCodeModel().ref(ResourceMethod.class);

  private final JClass _classClass = getCodeModel().ref(Class.class);

  private final JClass _objectClass = getCodeModel().ref(Object.class);

  private final HashSet<JClass> _generatedArrayClasses = new HashSet<JClass>();

  private final ClassLoader _classLoader;

  private final Config _config;

  protected static class Config extends DataTemplateGenerator.Config

  {

    public Config(String resolverPath,

                  String defaultPackage,

                  Boolean generateImported,

                  Boolean generateDataTemplates,

                  Boolean isRestli2Format)

    {

      super(resolverPath, defaultPackage, generateImported);

      _generateDataTemplates = generateDataTemplates;

      _isRestli2Format = isRestli2Format;

    }

    /**

     * @return true if the related data template source files will be generated as well, false otherwise.

     *         if null is assigned to this value, by default it returns true.

     */

    public boolean getGenerateDataTemplates()

    {

      return _generateDataTemplates == null || _generateDataTemplates;

    }

    public boolean isRestli2Format()

    {

      return _isRestli2Format;

    }

    private final Boolean _generateDataTemplates;

    private final Boolean _isRestli2Format;

  }

  /**

   * @param args Usage: RestRequestBuilderGenerator targetDirectoryPath sourceFilePaths

   * @throws IOException if there are problems opening or deleting files

   */

  public static void main(String[] args) throws IOException

  {

    if (args.length < 2)

    {

      log.error("Usage: RestRequestBuilderGenerator targetDirectoryPath [sourceFile or sourceDirectory]+");

      System.exit(1);

    }

    final String generateImported = System.getProperty(GENERATOR_GENERATE_IMPORTED);

    final String generateDataTemplates = System.getProperty(GENERATOR_REST_GENERATE_DATATEMPLATES);

    final boolean isRestli2Format = Boolean.getBoolean(GENERATOR_REST_GENERATE_RESTLI2);

    run(System.getProperty(GENERATOR_RESOLVER_PATH),

        System.getProperty(GENERATOR_DEFAULT_PACKAGE),

        generateImported == null ? null : Boolean.parseBoolean(generateImported),

        generateDataTemplates == null ? null : Boolean.parseBoolean(generateDataTemplates),

        isRestli2Format,

        args[0],

        Arrays.copyOfRange(args, 1, args.length));

  }

  public static GeneratorResult run(String resolverPath,

                                    String defaultPackage,

                                    Boolean generateImported,

                                    Boolean generateDataTemplates,

                                    Boolean isRestli2Format,

                                    String targetDirectoryPath,

                                    String[] sources) throws IOException

  {

    final Config config = new Config(resolverPath, defaultPackage, generateImported, generateDataTemplates, isRestli2Format);

    final RestRequestBuilderGenerator generator = new RestRequestBuilderGenerator(config);

    return generator.generate(targetDirectoryPath, sources);

  }

  public RestRequestBuilderGenerator(Config config)

  {

    super();

    _config = config;

    _classLoader = getClassLoader();

  }

  @Override

  protected Config getConfig()

  {

    return _config;

  }

  /**

   * Parses REST IDL files and generates Request builders from them.

   * @param sources path to IDL files or directories

   * @param targetDirectoryPath path to target root java source directory

   * @return a result that includes collection of files accessed, would have generated and actually modified.

   * @throws IOException if there are problems opening or deleting files.

   */

  private GeneratorResult generate(String targetDirectoryPath, String[] sources) throws IOException

  {

    List<File> sourceFiles = parseSources(sources);

    if(getMessage().length() > 0)

    {

      throw new IOException(getMessage().toString());

    }

    File targetDirectory = new File(targetDirectoryPath);

    List<File> targetFiles = targetFiles(targetDirectory);

    List<File> modifiedFiles;

    if (upToDate(sourceFiles, targetFiles))

    {

      modifiedFiles = Collections.emptyList();

      log.info("Target files are up-to-date: " + targetFiles);

    }

    else

    {

      modifiedFiles = targetFiles;

      log.info("Generating " + targetFiles.size() + " files: " + targetFiles);

      getCodeModel().build(new FileCodeWriter(targetDirectory, true));

    }

    return new Result(sourceFiles, targetFiles, modifiedFiles);

  }

  @Override

  protected boolean hideClass(JDefinedClass clazz)

  {

    if (getConfig().getGenerateDataTemplates() || _generatedArrayClasses.contains(clazz))

    {

      try

      {

        Class.forName(clazz.fullName(), false, _classLoader);

      }

      catch (ClassNotFoundException e)

      {

        return false;

      }

    }

    return super.hideClass(clazz);

  }

  @Override

  protected List<File> parseSources(String[] sourcePaths)

  {

    initializeDefaultPackage();

    initSchemaResolver();

    List<File> sourceFiles = new ArrayList<File>();

    for(String sourcePath : sourcePaths)

    {

      File source = new File(sourcePath);

      if (! source.exists())

      {

        getMessage().append("IDL file or directory doesn't exist: ").append(source.getAbsolutePath());

      }

      else

      {

        File[] sources;

        if (source.isDirectory())

        {

          FileUtil.FileExtensionFilter filter = new FileUtil.FileExtensionFilter(RestConstants.RESOURCE_MODEL_FILENAME_EXTENSION);

          List<File> sourceFilesInDirectory = FileUtil.listFiles(source, filter);

          sources = sourceFilesInDirectory.toArray(new File[0]);

        }

        else

        {

          sources = new File[] { source };

        }

        for (File sourceFile : sources)

        {

          sourceFiles.add(sourceFile);

          try

          {

            ResourceSchema resource = _codec.readResourceSchema(new FileInputStream(sourceFile));

            pushCurrentLocation(new FileDataSchemaLocation(sourceFile));

            generateResourceFacade(resource,

                                   sourceFile.getAbsolutePath(),

                                   new HashMap<String, JClass>(),

                                   new HashMap<String, JClass>(),

                                   new HashMap<String, List<String>>());

            popCurrentLocation();

          }

          catch (JClassAlreadyExistsException e)

          {

            // should never occur

            throw new IllegalStateException("Unexpected exception parsing " + sourceFile + ", " + e.getExistingClass().fullName() + " exists", e);

          }

          catch(JsonParseException e)

          {

            getMessage().append("Error parsing json file [").append(sourceFile.getAbsolutePath()).append("] [").

                            append(e.getMessage()).append(']');

          }

          catch(IOException e)

          {

            getMessage().append("Error processing file [").append(sourceFile.getAbsolutePath()).append(']').append(e.getMessage());

          }

        }

      }

    }

    appendSourceFilesFromSchemaResolver(sourceFiles);

    return sourceFiles;

  }

  private void annotate(JDefinedClass requestBuilderClass, String sourceFile)

  {

    annotate(requestBuilderClass, "Request Builder", sourceFile);

  }

  private JDefinedClass generateResourceFacade(ResourceSchema resource,

                                               String sourceFile,

                                               Map<String, JClass> pathKeyTypes,

                                               Map<String, JClass> assocKeyTypes,

                                               Map<String, List<String>> pathToAssocKeys)

          throws JClassAlreadyExistsException, IOException

  {

    ValidationResult validationResult = ValidateDataAgainstSchema.validate(resource.data(), resource.schema(),

                                                                           new ValidationOptions(

                                                                                           RequiredMode.MUST_BE_PRESENT));

    if (!validationResult.isValid())

    {

        throw new IllegalArgumentException(String.format(

                "Resource validation error.  Resource File '%s', Error Details '%s'",

                sourceFile,

                validationResult.toString()));

    }

    String resourceName = capitalize(resource.getName());

    String packageName = resource.getNamespace();

    JPackage clientPackage = (packageName == null || packageName.isEmpty()) ? getPackage() : getPackage(packageName);

    JDefinedClass facadeClass;

    if (_config.isRestli2Format())

    {

      facadeClass = clientPackage._class(resourceName + REQUEST_BUILDERS);

    }

    else

    {

      facadeClass = clientPackage._class(resourceName + BUILDERS);

    }

    annotate(facadeClass, sourceFile);

    final JFieldVar baseUriField;

    final JFieldVar requestOptionsField;

    final JExpression baseUriGetter = JExpr.invoke("getBaseUriTemplate");

    final JExpression requestOptionsGetter = JExpr.invoke("getRequestOptions");

    if (_config.isRestli2Format())

    {

      baseUriField = null;

      requestOptionsField = null;

      facadeClass._extends(BuilderBase.class);

    }

    else

    {

      // for old builder, instead of extending from RequestBuilderBase, add fields and getters in the class

      baseUriField = facadeClass.field(JMod.PRIVATE | JMod.FINAL, String.class, "_baseUriTemplate");

      requestOptionsField = facadeClass.field(JMod.PRIVATE, RestliRequestOptions.class, "_requestOptions");

      facadeClass.method(JMod.PRIVATE, String.class, "getBaseUriTemplate").body()._return(baseUriField);

      facadeClass.method(JMod.PUBLIC, RestliRequestOptions.class, "getRequestOptions").body()._return(requestOptionsField);

    }

    // make the original resource path available via a private final static variable.

    JFieldVar originalResourceField = facadeClass.field(JMod.PRIVATE | JMod.STATIC |JMod.FINAL, String.class,

                                                        "ORIGINAL_RESOURCE_PATH");

    String resourcePath = getResourcePath(resource.getPath());

    originalResourceField.init(JExpr.lit(resourcePath));

    // create reference to RestliRequestOptions.DEFAULT_OPTIONS

    final JClass restliRequestOptionsClass = getCodeModel().ref(RestliRequestOptions.class);

    JFieldRef defaultOptionsField = restliRequestOptionsClass.staticRef("DEFAULT_OPTIONS");

    if (!_config.isRestli2Format())

    {

      // same getPathComponents() logic as in RequestBuilderBase

      JMethod pathComponentsGetter = facadeClass.method(JMod.PUBLIC, String[].class, "getPathComponents");

      pathComponentsGetter.body()._return(getCodeModel().ref(URIParamUtils.class).staticInvoke("extractPathComponentsFromUriTemplate").arg(baseUriField));

      // method that expresses the following logic

      //   (requestOptions == null) ? return RestliRequestOptions.DEFAULT_OPTIONS : requestOptions;

      JMethod requestOptionsAssigner = facadeClass.method(JMod.PRIVATE | JMod.STATIC, RestliRequestOptions.class, "assignRequestOptions");

      JVar requestOptionsAssignerParam = requestOptionsAssigner.param(RestliRequestOptions.class, "requestOptions");

      JConditional requestNullCheck = requestOptionsAssigner.body()._if(requestOptionsAssignerParam.eq(JExpr._null()));

      requestNullCheck._then().block()._return(defaultOptionsField);

      requestNullCheck._else().block()._return(requestOptionsAssignerParam);

    }

    /*

    There will be 4 constructors:

      ()

      (RestliRequestOptions)

      (String)

      (String, RestliRequestOptions)

    */

    JMethod noArgConstructor = facadeClass.constructor(JMod.PUBLIC);

    JMethod requestOptionsOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);

    JMethod resourceNameOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);

    JMethod mainConstructor = facadeClass.constructor(JMod.PUBLIC);

    // no-argument constructor, delegates to the request options override constructor

    noArgConstructor.body().invoke(THIS).arg(defaultOptionsField);

    // request options override constructor

    JVar requestOptionsOverrideOptionsParam = requestOptionsOverrideConstructor.param(RestliRequestOptions.class, "requestOptions");

    if (_config.isRestli2Format())

    {

      requestOptionsOverrideConstructor.body().invoke(SUPER).arg(originalResourceField).arg(requestOptionsOverrideOptionsParam);

    }

    else

    {

      requestOptionsOverrideConstructor.body().assign(baseUriField, originalResourceField);

      final JInvocation requestOptionsOverrideAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(requestOptionsOverrideOptionsParam);

      requestOptionsOverrideConstructor.body().assign(requestOptionsField, requestOptionsOverrideAssignRequestOptions);

    }

    // primary resource name override constructor, delegates to the main constructor

    JVar resourceNameOverrideResourceNameParam = resourceNameOverrideConstructor.param(_stringClass, "primaryResourceName");

    resourceNameOverrideConstructor.body().invoke(THIS).arg(resourceNameOverrideResourceNameParam).arg(defaultOptionsField);

    // main constructor

    JVar mainConsResourceNameParam = mainConstructor.param(_stringClass, "primaryResourceName");

    JVar mainConsOptionsParam = mainConstructor.param(RestliRequestOptions.class, "requestOptions");

    JExpression baseUriExpr;

    if (resourcePath.contains("/"))

    {

      baseUriExpr = originalResourceField.invoke("replaceFirst").arg(JExpr.lit("[^/]*/")).arg(mainConsResourceNameParam.plus(JExpr.lit("/")));

    }

    else

    {

      baseUriExpr = mainConsResourceNameParam;

    }

    if (_config.isRestli2Format())

    {

      mainConstructor.body().invoke(SUPER).arg(baseUriExpr).arg(mainConsOptionsParam);

    }

    else

    {

      final JInvocation mainAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(mainConsOptionsParam);

      mainConstructor.body().assign(baseUriField, baseUriExpr);

      mainConstructor.body().assign(requestOptionsField, mainAssignRequestOptions);

    }

    JMethod primaryResourceGetter = facadeClass.method(JMod.PUBLIC | JMod.STATIC, String.class, "getPrimaryResource");

    primaryResourceGetter.body()._return(originalResourceField);

    List<String> pathKeys = getPathKeys(resourcePath, pathToAssocKeys);

    JClass keyTyperefClass = null;

    JClass keyClass;

    JClass keyKeyClass = null;

    JClass keyParamsClass = null;

    Class<?> resourceSchemaClass;

    Map<String, AssocKeyTypeInfo> assocKeyTypeInfos = Collections.emptyMap();

    StringArray supportsList=null;

    RestMethodSchemaArray restMethods = null;

    FinderSchemaArray finders = null;

    ResourceSchemaArray subresources = null;

    ActionSchemaArray resourceActions = null;

    ActionSchemaArray entityActions = null;

    if (resource.getCollection() != null)

    {

      resourceSchemaClass = CollectionSchema.class;

      CollectionSchema collection = resource.getCollection();

      String keyName = collection.getIdentifier().getName();

      // In case of collection with a simple key, return the one specified by "type" in

      // the "identifier". Otherwise, get both "type" and "params", and return

      // ComplexKeyResource parameterized by those two.

      if (collection.getIdentifier().getParams() == null)

      {

        keyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;

        JClass declaredClass = getClassRefForSchema(RestSpecCodec.textToSchema(collection.getIdentifier().getType(), getSchemaResolver()), facadeClass);

        if(!declaredClass.equals(keyClass))

        {

          keyTyperefClass = declaredClass;

        }

      }

      else

      {

        keyKeyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;

        keyParamsClass = getJavaBindingType(collection.getIdentifier().getParams(), facadeClass).valueClass;

        keyClass = getCodeModel().ref(ComplexResourceKey.class).narrow(keyKeyClass, keyParamsClass);

      }

      pathKeyTypes.put(keyName, keyClass);

      supportsList = collection.getSupports();

      restMethods = collection.getMethods();

      finders = collection.getFinders();

      subresources = collection.getEntity().getSubresources();

      resourceActions = collection.getActions();

      entityActions = collection.getEntity().getActions();

    }

    else if (resource.getAssociation() != null)

    {

      resourceSchemaClass = AssociationSchema.class;

      AssociationSchema association = resource.getAssociation();

      keyClass = getCodeModel().ref(CompoundKey.class);

      supportsList = association.getSupports();

      restMethods = association.getMethods();

      finders = association.getFinders();

      subresources = association.getEntity().getSubresources();

      resourceActions = association.getActions();

      entityActions = association.getEntity().getActions();

      assocKeyTypeInfos = generateAssociationKey(facadeClass, association);

      String keyName = getAssociationKey(resource, association);

      pathKeyTypes.put(keyName, keyClass);

      List<String> assocKeys = new ArrayList<String>(4);

      for(Map.Entry<String, AssocKeyTypeInfo> entry: assocKeyTypeInfos.entrySet())

      {

        assocKeys.add(entry.getKey());

        assocKeyTypes.put(entry.getKey(), entry.getValue().getBindingType());

      }

      pathToAssocKeys.put(keyName, assocKeys);

    }

    else if (resource.getSimple() != null)

    {

      resourceSchemaClass = SimpleSchema.class;

      SimpleSchema simpleSchema = resource.getSimple();

      keyClass = _voidClass;

      supportsList = simpleSchema.getSupports();

      restMethods = simpleSchema.getMethods();

      subresources = simpleSchema.getEntity().getSubresources();

      resourceActions = simpleSchema.getActions();

    }

    else if (resource.getActionsSet() != null)

    {

      resourceSchemaClass = ActionsSetSchema.class;

      ActionsSetSchema actionsSet = resource.getActionsSet();

      resourceActions = actionsSet.getActions();

      keyClass = _voidClass;

    }

    else

    {

      throw new IllegalArgumentException("unsupported resource type for resource: '" + resourceName + '\'');

    }

    generateOptions(facadeClass, baseUriGetter, requestOptionsGetter);

    JFieldVar resourceSpecField = facadeClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, _resourceSpecClass, "_resourceSpec");

    if (resourceSchemaClass == CollectionSchema.class ||

        resourceSchemaClass == AssociationSchema.class ||

        resourceSchemaClass == SimpleSchema.class)

    {

      JClass schemaClass = getJavaBindingType(resource.getSchema(), null).schemaClass;

      Set<ResourceMethod> supportedMethods = getSupportedMethods(supportsList);

      JInvocation supportedMethodsExpr;

      if (supportedMethods.isEmpty())

      {

        supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());

      }

      else

      {

        supportedMethodsExpr = _enumSetClass.staticInvoke("of");

        for (ResourceMethod resourceMethod: supportedMethods)

        {

          validateResourceMethod(resourceSchemaClass, resourceName, resourceMethod);

          supportedMethodsExpr.arg(_resourceMethodClass.staticRef(resourceMethod.name()));

        }

      }

      JBlock staticInit = facadeClass.init();

      JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions,

                                                   staticInit);

      JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions,

                                                       staticInit);

      if (resourceSchemaClass == CollectionSchema.class ||

          resourceSchemaClass == AssociationSchema.class)

      {

        JClass assocKeyClass = getCodeModel().ref(TypeInfo.class);

        JClass hashMapClass = getCodeModel().ref(HashMap.class).narrow(_stringClass, assocKeyClass);

        JVar keyPartsVar = staticInit.decl(hashMapClass, "keyParts").init(JExpr._new(hashMapClass));

        for (Map.Entry<String, AssocKeyTypeInfo> typeInfoEntry : assocKeyTypeInfos.entrySet())

        {

          AssocKeyTypeInfo typeInfo = typeInfoEntry.getValue();

          JInvocation typeArg = JExpr._new(assocKeyClass)

            .arg(typeInfo.getBindingType().dotclass())

            .arg(typeInfo.getDeclaredType().dotclass());

          staticInit.add(keyPartsVar.invoke("put").arg(typeInfoEntry.getKey()).arg(typeArg));

        }

        staticInit.assign(resourceSpecField,

                          JExpr._new(_resourceSpecImplClass)

                                  .arg(supportedMethodsExpr)

                                  .arg(methodSchemaMap)

                                  .arg(responseSchemaMap)

                                  .arg(keyTyperefClass == null ? keyClass.dotclass() : keyTyperefClass.dotclass())

                                  .arg(keyKeyClass == null ? JExpr._null() : keyKeyClass.dotclass())

                                  .arg(keyKeyClass == null ? JExpr._null() : keyParamsClass.dotclass())

                                  .arg(schemaClass.dotclass())

                                  .arg(keyPartsVar));

      }

      else //simple schema

      {

        staticInit.assign(resourceSpecField,

                          JExpr._new(_resourceSpecImplClass)

                              .arg(supportedMethodsExpr)

                              .arg(methodSchemaMap)

                              .arg(responseSchemaMap)

                              .arg(schemaClass.dotclass()));

      }

      generateBasicMethods(facadeClass,

                           baseUriGetter,

                           keyClass,

                           schemaClass,

                           supportedMethods,

                           restMethods,

                           resourceSpecField,

                           resourceName,

                           pathKeys,

                           pathKeyTypes,

                           assocKeyTypes,

                           pathToAssocKeys,

                           requestOptionsGetter);

      if (resourceSchemaClass == CollectionSchema.class ||

          resourceSchemaClass == AssociationSchema.class)

      {

        generateFinders(facadeClass,

                        baseUriGetter,

                        finders,

                        keyClass,

                        schemaClass,

                        assocKeyTypeInfos,

                        resourceSpecField,

                        resourceName,

                        pathKeys,

                        pathKeyTypes,

                        assocKeyTypes,

                        pathToAssocKeys,

                        requestOptionsGetter);

      }

      generateSubResources(sourceFile, subresources, pathKeyTypes, assocKeyTypes, pathToAssocKeys);

    }

    else //action set

    {

      JBlock staticInit = facadeClass.init();

      JInvocation supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());

      JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions,

                                                   staticInit);

      JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions,

                                                       staticInit);

      staticInit.assign(resourceSpecField,

                        JExpr._new(_resourceSpecImplClass)

                                .arg(supportedMethodsExpr)

                                .arg(methodSchemaMap)

                                .arg(responseSchemaMap)

                                .arg(keyClass.dotclass())

                                .arg(JExpr._null())

                                .arg(JExpr._null())

                                .arg(JExpr._null())

                                .arg(getCodeModel().ref(Collections.class).staticInvoke(

                                        "<String, Class<?>>emptyMap")));

    }

    generateActions(facadeClass,

                    baseUriGetter,

                    resourceActions,

                    entityActions,

                    keyClass,

                    resourceSpecField,

                    resourceName,

                    pathKeys,

                    pathKeyTypes,

                    assocKeyTypes,

                    pathToAssocKeys,

                    requestOptionsGetter);

    generateClassJavadoc(facadeClass, resource);

    generateClassAnnotations(facadeClass, resource);

    return facadeClass;

  }

  private String getAssociationKey(ResourceSchema resource, AssociationSchema association)

  {

    if (association.getIdentifier() == null)

    {

      return resource.getName() + "Id";

    }

    else

    {

      return association.getIdentifier();

    }

  }

  private static List<String> fixOldStylePathKeys(List<String> pathKeys, String resourcePath, Map<String, List<String>> pathToAssocKeys)

  {

    if (resourcePath.contains("="))

    {

      // this is an old-style IDL.

      List<String> newPathKeys = new ArrayList<String>(pathKeys.size());

      Map<String, String> assocToPathKeys = reverseMap(pathToAssocKeys);

      Set<String> prevRealPathKeys = new HashSet<String>();

      for (String currKey : pathKeys)

      {

        if (assocToPathKeys.containsKey(currKey))

        {

          // currKey actually an assocKey

          if (!prevRealPathKeys.contains(assocToPathKeys.get(currKey)))

          {

            // if we already added the real path key, don't add it again.

            prevRealPathKeys.add(assocToPathKeys.get(currKey));

            newPathKeys.add(assocToPathKeys.get(currKey));

          }

        }

        else

        {

          newPathKeys.add(currKey);

        }

      }

      return newPathKeys;

    }

    else

    {

      return pathKeys;

    }

  }

  private static Map<String, String> reverseMap(Map<String, List<String>> toReverse)

  {

    Map<String, String> reversed = new HashMap<String, String>();

    for (Map.Entry<String, List<String>> entry: toReverse.entrySet())

    {

      for (String element : entry.getValue())

      {

        reversed.put(element, entry.getKey());

      }

    }

    return reversed;

  }

  private void validateResourceMethod(Class<?> resourceSchemaClass, String resourceName, ResourceMethod resourceMethod)

  {

    if (resourceSchemaClass == SimpleSchema.class && !RestConstants.SIMPLE_RESOURCE_METHODS.contains(resourceMethod))

    {

      throw new IllegalArgumentException(

          String.format(

              "'%s' is not a supported method on resource: '%s'", resourceMethod.toString(), resourceName));

    }

  }

  private JVar responseMetadataMapInit(JDefinedClass facadeClass,

                                       ActionSchemaArray resourceActions,

                                       ActionSchemaArray entityActions,

                                       JBlock staticInit) // lets work on this first...

  {

    JClass MetadataMapClass = getCodeModel().ref(HashMap.class).narrow(_stringClass, getCodeModel().ref(DynamicRecordMetadata.class));

    JVar responseMetadataMap = staticInit.decl(MetadataMapClass, "responseMetadataMap").init(JExpr._new(MetadataMapClass));

    // get all actions into a single ActionSchemaArray

    int resourceActionsSize = resourceActions == null ? 0 : resourceActions.size();

    int entityActionsSize = entityActions == null ? 0 : entityActions.size();

    ActionSchemaArray allActionSchema = new ActionSchemaArray(resourceActionsSize + entityActionsSize);

    allActionSchema.addAll(resourceActions == null ? new ActionSchemaArray() : resourceActions);

    allActionSchema.addAll(entityActions == null ? new ActionSchemaArray() : entityActions);

    String returnName = "value";

    for(ActionSchema actionSchema : allActionSchema)

    {

      String methodName = actionSchema.getName();

      JInvocation returnFieldDefs;

      if (actionSchema.hasReturns())

      {

        JInvocation returnFieldDef = createFieldDef(returnName, actionSchema.getReturns(), facadeClass);

        returnFieldDefs = getCodeModel().ref(Collections.class).staticInvoke("singletonList").arg(returnFieldDef);

      }

      else

      {

        returnFieldDefs = getCodeModel().ref(Collections.class).staticInvoke("<FieldDef<?>>emptyList");

      }

      JInvocation returnMetadata = createMetadata(methodName, returnFieldDefs);

      staticInit.add(responseMetadataMap.invoke("put").arg(methodName).arg(returnMetadata));

    }

    return responseMetadataMap;

  }

  private JVar methodMetadataMapInit(JDefinedClass facadeClass,

                                     ActionSchemaArray resourceActions,

                                     ActionSchemaArray entityActions,

                                     JBlock staticInit)

  {

    // CreateMetadata (only for actions right now)

    JClass MetadataMapClass = getCodeModel().ref(HashMap.class).narrow(_stringClass, getCodeModel().ref(DynamicRecordMetadata.class));

    JVar requestMetadataMap = staticInit.decl(MetadataMapClass, "requestMetadataMap").init(JExpr._new(MetadataMapClass));

    JClass fieldDefListClass = getCodeModel().ref(ArrayList.class).narrow(getCodeModel().ref(FieldDef.class).narrow(getCodeModel().ref(Object.class).wildcard()));

    // get all actions into a single ActionSchemaArray

    int resourceActionsSize = resourceActions == null ? 0 : resourceActions.size();

    int entityActionsSize = entityActions == null ? 0 : entityActions.size();

    ActionSchemaArray allActionSchema = new ActionSchemaArray(resourceActionsSize + entityActionsSize);

    allActionSchema.addAll(resourceActions == null ? new ActionSchemaArray() : resourceActions);

    allActionSchema.addAll(entityActions == null ? new ActionSchemaArray() : entityActions);

    for(ActionSchema actionSchema : allActionSchema)

    {

      String varName = actionSchema.getName() + "Params";

      JVar currMethodParams = staticInit.decl(fieldDefListClass, varName).init(JExpr._new(fieldDefListClass));

      ParameterSchemaArray parameters = actionSchema.getParameters();

      for (ParameterSchema parameterSchema : parameters == null? new ParameterSchemaArray() : parameters)

      {

        JInvocation fieldDefParam = createFieldDef(parameterSchema.getName(), parameterSchema.getType(), facadeClass);

        staticInit.add(currMethodParams.invoke("add").arg(fieldDefParam));

      }

      String methodName = actionSchema.getName();

      JInvocation newSchema = createMetadata(methodName, currMethodParams);

      staticInit.add(requestMetadataMap.invoke("put").arg(methodName).arg(newSchema));

    }

    return requestMetadataMap;

  }

  /**

   * Helper class to create FieldDefs

   *

   * @param name the fieldDef name

   * @param type the fieldDef type

   * @param parent the class the FieldDef is being created in

   * @return JInvocation of the creation of the FieldDef

   */

  private JInvocation createFieldDef(String name, String type, JDefinedClass parent)

  {

    JavaBinding binding = getJavaBindingType(type, parent);

    JExpression schema = getCodeModel().ref(DataTemplateUtil.class).staticInvoke("getSchema").arg(binding.schemaClass.dotclass());

    JInvocation fieldDefInvocation = JExpr._new(getCodeModel().ref(FieldDef.class).narrow(binding.valueClass))

        .arg(name).arg(binding.valueClass.dotclass())

        .arg(schema);

    return fieldDefInvocation;

  }

  private JInvocation createMetadata(String name, JExpression fieldDefs)

  {

    return JExpr._new(getCodeModel().ref(DynamicRecordMetadata.class)).arg(name).arg(fieldDefs);

  }

  /**

   * Get the key class. In case of collection with a simple key, return the one specified by "type" in the

   * "identifier". Otherwise, get both "type" and "params", and return ComplexKeyResource parameterized by

   * those two.

   *

   * @param collection

   * @param facadeClass

   * @return JClass as described above

   */

  private JClass getKeyClass(CollectionSchema collection, JDefinedClass facadeClass) {

    JClass keyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;

    if (collection.getIdentifier().getParams() == null)

    {

      return keyClass;

    }

    JClass paramsClass = getJavaBindingType(collection.getIdentifier().getParams(), facadeClass).valueClass;

    return getCodeModel().ref(ComplexResourceKey.class).narrow(keyClass, paramsClass);

  }

  private static List<String> getPathKeys(String basePath, Map<String, List<String>> pathToAssocKeys)

  {

    UriTemplate template = new UriTemplate(basePath);

    return fixOldStylePathKeys(template.getTemplateVariables(), basePath, pathToAssocKeys);

  }

  private void generateOptions(JDefinedClass facadeClass, JExpression baseUriExpr, JExpression requestOptionsExpr)

  {

    JClass builderClass = getCodeModel().ref(OptionsRequestBuilder.class);

    JMethod finderMethod = facadeClass.method(JMod.PUBLIC, OptionsRequestBuilder.class, "options");

    finderMethod.body()._return(JExpr._new(builderClass).arg(baseUriExpr).arg(requestOptionsExpr));

  }

  private void generateSubResources(String sourceFile,

                                    ResourceSchemaArray subresources,

                                    Map<String, JClass> pathKeyTypes,

                                    Map<String, JClass> assocKeyTypes,

                                    Map<String, List<String>> pathToAssocKeys)

          throws JClassAlreadyExistsException, IOException

  {

    if (subresources == null)

    {

      return;

    }

    for (ResourceSchema resource : subresources)

    {

      generateResourceFacade(resource, sourceFile, pathKeyTypes, assocKeyTypes, pathToAssocKeys);

    }

  }

  private void generateFinders(JDefinedClass facadeClass,

                               JExpression baseUriExpr,

                               FinderSchemaArray finderSchemas,

                               JClass keyClass,

                               JClass valueClass,

                               Map<String, AssocKeyTypeInfo> assocKeys,

                               JVar resourceSpecField,

                               String resourceName,

                               List<String> pathKeys,

                               Map<String, JClass> pathKeyTypes,

                               Map<String, JClass> assocKeyTypes,

                               Map<String, List<String>> pathToAssocKeys,

                               JExpression requestOptionsExpr)

          throws JClassAlreadyExistsException

  {

    if (finderSchemas != null)

    {

      JClass baseBuilderClass = getCodeModel().ref(FindRequestBuilderBase.class).narrow(keyClass, valueClass);

      for (FinderSchema finder : finderSchemas)

      {

        String finderName = finder.getName();

        String builderName;

        if (_config.isRestli2Format())

        {

          builderName = capitalize(resourceName) + "FindBy" + capitalize(finderName) + REQUEST_BUILDER;

        }

        else

        {

          builderName = capitalize(resourceName) + "FindBy" + capitalize(finderName) + BUILDER;

        }

        JDefinedClass finderBuilderClass = generateDerivedBuilder(baseBuilderClass,

                                                                  valueClass,

                                                                  finderName,

                                                                  builderName,

                                                                  facadeClass.getPackage());

        JMethod finderMethod = facadeClass.method(JMod.PUBLIC, finderBuilderClass,

                                                "findBy" + capitalize(finderName));

        finderMethod.body()._return(JExpr._new(finderBuilderClass).arg(baseUriExpr).arg(resourceSpecField).arg(requestOptionsExpr));

        Set<String> finderKeys = new HashSet<String>();

        if (finder.getAssocKey() != null)

        {

          finderKeys.add(finder.getAssocKey());

        }

        if (finder.getAssocKeys() != null)

        {

          for (String assocKey : finder.getAssocKeys())

          {

            finderKeys.add(assocKey);

          }

        }

        generatePathKeyBindingMethods(pathKeys, finderBuilderClass, pathKeyTypes, assocKeyTypes, pathToAssocKeys);

        generateAssocKeyBindingMethods(assocKeys, finderBuilderClass, finderKeys);

        if (finder.getParameters() != null)

        {

          generateQueryParamBindingMethods(facadeClass, finder.getParameters(), finderBuilderClass);

        }

        //process the metadata schema file

        if (finder.getMetadata() != null)

        {

          String metadataClass = finder.getMetadata().getType();

          getJavaBindingType(metadataClass, facadeClass);

        }

        generateClassJavadoc(finderBuilderClass, finder);

        generateFactoryMethodJavadoc(finderMethod, finder);

      }

    }

  }

  private void generateQueryParamBindingMethods(JDefinedClass facadeClass,

                                                ParameterSchemaArray parameters,

                                                JDefinedClass derivedBuilderClass)

  {

    for (ParameterSchema param : parameters)

    {

      if ("array".equals(param.getType()))

      {

        final JClass paramItemsClass = getJavaBindingType(param.getItems(), facadeClass).valueClass;

        final JClass paramClass = getCodeModel().ref(Iterable.class).narrow(paramItemsClass);

        generateQueryParamSetMethod(derivedBuilderClass, param, paramClass);

        generateQueryParamAddMethod(derivedBuilderClass, param, paramItemsClass);

      }

      else

      {

        final DataSchema typeSchema = RestSpecCodec.textToSchema(param.getType(), getSchemaResolver());

        final JClass paramClass = getJavaBindingType(typeSchema, facadeClass).valueClass;

        generateQueryParamSetMethod(derivedBuilderClass, param, paramClass);

        // we deprecate the "items" field from ParameterSchema, which generates Iterable<Foo> in the builder

        // instead, we use the standard way to represent arrays, which generates FooArray

        // for backwards compatibility, add the method with Iterable<Foo> parameter

        if (typeSchema instanceof ArrayDataSchema)

        {

          final DataSchema itemsSchema = ((ArrayDataSchema) typeSchema).getItems();

          final JClass paramItemsClass = getJavaBindingType(itemsSchema, facadeClass).valueClass;

          final JClass iterableItemsClass = getCodeModel().ref(Iterable.class).narrow(paramItemsClass);

          generateQueryParamSetMethod(derivedBuilderClass, param, iterableItemsClass);

          generateQueryParamAddMethod(derivedBuilderClass, param, paramItemsClass);

        }

      }

    }

  }

  private JDefinedClass generateDerivedBuilder(JClass baseBuilderClass,

                                               JClass valueClass,

                                               String finderName,

                                               String derivedBuilderName,

                                               JPackage clientPackage)

          throws JClassAlreadyExistsException

  {

    JDefinedClass derivedBuilderClass = clientPackage._class(JMod.PUBLIC, derivedBuilderName);

    annotate(derivedBuilderClass, null);

    derivedBuilderClass._extends(baseBuilderClass.narrow(derivedBuilderClass));

    JMethod derivedBuilderConstructor = derivedBuilderClass.constructor(JMod.PUBLIC);

    JVar uriParam = derivedBuilderConstructor.param(_stringClass, "baseUriTemplate");

    JVar resourceSpecParam = derivedBuilderConstructor.param(_resourceSpecClass, "resourceSpec");

    JVar requestOptionsParam = derivedBuilderConstructor.param(RestliRequestOptions.class, "requestOptions");

    JInvocation invocation = derivedBuilderConstructor.body().invoke(SUPER).arg(uriParam);

    // the new BatchGetEntityRequestBuilderBase does not need the valueClass parameter in constructor

    if (!baseBuilderClass.fullName().startsWith(BatchGetEntityRequestBuilderBase.class.getName() + "<"))

    {

      invocation.arg(valueClass.dotclass());

    }

    invocation.arg(resourceSpecParam).arg(requestOptionsParam);

    if (finderName != null)

    {

      derivedBuilderConstructor.body().add(JExpr._super().invoke("name").arg(finderName));

    }

    return derivedBuilderClass;

  }

  private void generateAssocKeyBindingMethods(Map<String, AssocKeyTypeInfo> assocKeys,

                                              JDefinedClass finderBuilderClass,

                                              Set<String> finderKeys)

  {

    StringBuilder errorBuilder = new StringBuilder();

    for (String assocKey : finderKeys)

    {

      JClass assocKeyClass = assocKeys.get(assocKey).getBindingType();

      if (assocKeyClass == null)

      {

        errorBuilder.append(String.format("assocKey %s in finder is not found\n", assocKey));

        continue;

      }

      JMethod keyMethod = finderBuilderClass.method(JMod.PUBLIC, finderBuilderClass, RestLiToolsUtils.nameCamelCase(

          assocKey + "Key"));

      JVar keyMethodParam = keyMethod.param(assocKeyClass, "key");

      keyMethod.body().add(JExpr._super().invoke("assocKey").arg(assocKey).arg(keyMethodParam));

      keyMethod.body()._return(JExpr._this());

    }

    if (errorBuilder.length() > 0)

    {

      throw new IllegalArgumentException(errorBuilder.toString());

    }

  }

  private void generatePathKeyBindingMethods(List<String> pathKeys,

                                             JDefinedClass builderClass,

                                             Map<String, JClass> pathKeyTypes,

                                             Map<String, JClass> assocKeyTypes,

                                             Map<String, List<String>> pathToAssocKeys)

  {

    for (String pathKey : pathKeys)

    {

      if (pathToAssocKeys.get(pathKey) != null)

      {

        JFieldVar compoundKey = builderClass.field(JMod.PRIVATE,

                                                   CompoundKey.class,

                                                   RestLiToolsUtils.nameCamelCase(pathKey),

                                                   JExpr._new(pathKeyTypes.get(pathKey)));

        for (String assocKeyName : pathToAssocKeys.get(pathKey))

        {

          JMethod assocKeyMethod = builderClass.method(JMod.PUBLIC, builderClass, RestLiToolsUtils.nameCamelCase(

              assocKeyName + "Key"));

          JVar assocKeyMethodParam = assocKeyMethod.param(assocKeyTypes.get(assocKeyName), "key");

          // put stuff into CompoundKey

          assocKeyMethod.body().add(compoundKey.invoke("append").arg(assocKeyName).arg(assocKeyMethodParam));

          // old and new super.pathKey()s

          assocKeyMethod.body().add(JExpr._super().invoke("pathKey").arg(assocKeyName).arg(assocKeyMethodParam));

          assocKeyMethod.body().add(JExpr._super().invoke("pathKey").arg(pathKey).arg(compoundKey)); // new...

          assocKeyMethod.body()._return(JExpr._this());

        }

      }

      else

      {

        JMethod keyMethod = builderClass.method(JMod.PUBLIC, builderClass, RestLiToolsUtils.nameCamelCase(pathKey + "Key"));

        JVar keyMethodParam = keyMethod.param(pathKeyTypes.get(pathKey), "key");

        keyMethod.body().add(JExpr._super().invoke("pathKey").arg(pathKey).arg(keyMethodParam));

        keyMethod.body()._return(JExpr._this());

      }

    }

  }

  private void generateActions(JDefinedClass facadeClass,

                               JExpression baseUriExpr,

                               ActionSchemaArray resourceActions,

                               ActionSchemaArray entityActions,

                               JClass keyClass,

                               JVar resourceSpecField,

                               String resourceName,

                               List<String> pathKeys,

                               Map<String, JClass> pathKeyTypes,

                               Map<String, JClass> assocKeyTypes,

                               Map<String, List<String>> pathToAssocKeys,

                               JExpression requestOptionsExpr)

          throws JClassAlreadyExistsException

  {

    if (resourceActions != null)

    {

      for (ActionSchema action : resourceActions)

      {

        generateActionMethod(facadeClass,

                             baseUriExpr,

                             _voidClass,

                             action,

                             resourceSpecField,

                             resourceName,

                             pathKeys,

                             pathKeyTypes,

                             assocKeyTypes,

                             pathToAssocKeys,

                             requestOptionsExpr);

      }

    }

    if (entityActions != null)

    {

      for (ActionSchema action : entityActions)

      {

        generateActionMethod(facadeClass,