private Collection<MimeType> getUniqueResponseMimeTypes(final Action action) {
   final Map<String, MimeType> responseMimeTypes = new HashMap<String, MimeType>();
   for (final Response response : action.getResponses().values()) {
     if (response.getBody() != null && !response.getBody().isEmpty()) {
       for (final MimeType responseMimeType : response.getBody().values()) {
         if (responseMimeType != null) {
           responseMimeTypes.put(responseMimeType.getType(), responseMimeType);
         }
       }
     }
   }
   return responseMimeTypes.values();
 }
  private void createResponseBuilderInResourceMethodReturnType(
      final Action action,
      final JDefinedClass responseClass,
      final Entry<String, Response> statusCodeAndResponse)
      throws Exception {
    final int statusCode = NumberUtils.toInt(statusCodeAndResponse.getKey());
    final Response response = statusCodeAndResponse.getValue();

    if (response.getBody() == null || response.getBody().isEmpty()) {
      createResponseBuilderInResourceMethodReturnType(responseClass, statusCode, response, null);
    } else {
      for (final MimeType mimeType : response.getBody().values()) {
        createResponseBuilderInResourceMethodReturnType(
            responseClass, statusCode, response, mimeType);
      }
    }
  }
  private void addMethod(
      ActionType action,
      Resource res,
      IMethodModel m,
      IDocInfo documentation,
      String returnName,
      String parameterName) {
    Action value = new Action();

    value.setType(action);
    res.getActions().put(action, value);
    IParameterModel[] parameters = m.getParameters();
    String[] responseCodes = new String[] {ResourceVisitor.DEFAULT_RESPONSE};
    String[] responseDescriptions = new String[] {null};
    if (config != null) {
      responseCodes = new String[] {config.getResponseCode(action)};
    }
    IAnnotationModel annotation = m.getAnnotation(ResourceVisitor.API_RESPONSE);
    if (annotation != null) {
      responseCodes = new String[] {annotation.getValue(ResourceVisitor.CODE)};
      responseDescriptions = new String[] {annotation.getValue(ResourceVisitor.MESSAGE)};
    }
    annotation = m.getAnnotation(ResourceVisitor.API_RESPONSES);
    if (annotation != null) {
      IAnnotationModel[] subAnnotations = annotation.getSubAnnotations("value");
      responseCodes = new String[subAnnotations.length];
      responseDescriptions = new String[subAnnotations.length];
      int a = 0;
      for (IAnnotationModel mq : subAnnotations) {
        responseCodes[a++] = mq.getValue(ResourceVisitor.CODE);
        responseDescriptions[a - 1] = mq.getValue(ResourceVisitor.MESSAGE);
      }
    }
    for (IParameterModel pm : parameters) {
      if (pm.hasAnnotation(QUERY_PARAM)) {
        String annotationValue = pm.getAnnotationValue(QUERY_PARAM);
        String type = pm.getType();
        QueryParameter value2 = new QueryParameter();
        configureParam(pm, value2);
        proceedType(type, value2, pm);
        String text = documentation.getDocumentation(pm.getName());
        if (!"".equals(text)) { // $NON-NLS-1$
          value2.setDescription(text);
        }
        value.getQueryParameters().put(annotationValue, value2);
      }
    }
    for (IParameterModel pm : parameters) {
      if (pm.hasAnnotation(HEADER_PARAM)) {
        String annotationValue = pm.getAnnotationValue(HEADER_PARAM);
        Header value2 = new Header();
        configureParam(pm, value2);
        proceedType(pm.getType(), value2, pm);
        String text = documentation.getDocumentation(pm.getName());
        if (!"".equals(text)) { // $NON-NLS-1$
          value2.setDescription(text);
        }
        value.getHeaders().put(annotationValue, value2);
      }
    }
    for (IParameterModel pm : parameters) {
      if (pm.hasAnnotation(PATH_PARAM)) {
        String annotationValue = pm.getAnnotationValue(PATH_PARAM);
        UriParameter value2 = new UriParameter();
        configureParam(pm, value2);
        String text = documentation.getDocumentation(pm.getName());
        if (!"".equals(text)) { // $NON-NLS-1$
          value2.setDescription(text);
        }
        proceedType(pm.getType(), value2, pm);
        res.getUriParameters().put(annotationValue, value2);
      }
    }

    String[] consumesValue = m.getAnnotationValues(CONSUMES);
    if (consumesValue == null) {
      consumesValue = classConsumes;
    }
    if (consumesValue != null) {
      for (String s : consumesValue) {
        s = sanitizeMediaType(s);
        MimeType bodyType = new MimeType();
        if (s.contains(XML)) {
          bodyType.setSchema(parameterName);
          if (parameterName != null) {
            bodyType.setExample(EXAMPLES_PREFFIX + parameterName + XML_FILE_EXT);
            bodyType.setExampleOrigin(EXAMPLES_PREFFIX + parameterName + XML_FILE_EXT);
          }
        }
        if (s.contains(JSON)) {
          if (parameterName != null) {
            bodyType.setSchema(parameterName + ResourceVisitor.JSONSCHEMA); // $NON-NLS-1$
            bodyType.setExample(EXAMPLES_PREFFIX + parameterName + JSON_FILE_EXT);
            bodyType.setExampleOrigin(EXAMPLES_PREFFIX + parameterName + JSON_FILE_EXT);
          }
        }
        bodyType.setType(s);
        if (s.contains(FORM)) {
          for (IParameterModel pm : parameters) {
            if (pm.hasAnnotation(FORM_PARAM)) {
              String annotationValue = pm.getAnnotationValue(FORM_PARAM);
              FormParameter vl = new FormParameter();
              configureParam(pm, vl);
              String text = documentation.getDocumentation(pm.getName());
              if (!"".equals(text)) { // $NON-NLS-1$
                vl.setDescription(text);
              }
              proceedType(pm.getType(), vl, pm);
              ArrayList<FormParameter> arrayList = new ArrayList<FormParameter>();
              arrayList.add(vl);
              if (bodyType.getFormParameters() == null) {
                bodyType.setFormParameters(new HashMap<String, java.util.List<FormParameter>>());
              }
              bodyType.getFormParameters().put(annotationValue, arrayList);
            }
          }
        }
        value.getBody().put(s, bodyType);
      }
    }
    String[] producesValue = m.getAnnotationValues(PRODUCES);
    if (producesValue == null) {
      producesValue = classProduces;
    }
    int a = 0;
    for (String responseCode : responseCodes) {
      if (producesValue != null) {
        Response value2 = new Response();
        String text = documentation.getReturnInfo();
        String respDesc = responseDescriptions[a];
        if (respDesc != null && respDesc.length() > 0) {
          text = respDesc;
        }
        a++;
        if (!"".equals(text)) { // $NON-NLS-1$
          value2.setDescription(text);
        }
        for (String s : producesValue) {
          s = sanitizeMediaType(s);
          MimeType mimeType = new MimeType();
          if (returnName != null) {
            if (s.contains(XML)) {
              mimeType.setSchema(returnName);
              if (returnName != null) {
                mimeType.setExample(EXAMPLES_PREFFIX + returnName + XML_FILE_EXT);
                mimeType.setExampleOrigin(EXAMPLES_PREFFIX + returnName + XML_FILE_EXT);
              }
            }
            if (s.contains(JSON)) {
              if (returnName != null) {
                mimeType.setSchema(returnName + ResourceVisitor.JSONSCHEMA); // $NON-NLS-1$
                mimeType.setExample(EXAMPLES_PREFFIX + returnName + JSON_FILE_EXT);
                mimeType.setExampleOrigin(EXAMPLES_PREFFIX + returnName + JSON_FILE_EXT);
              }
            }
          }
          mimeType.setType(s);
          value2.getBody().put(s, mimeType);
        }
        value.getResponses().put(responseCode, value2); // $NON-NLS-1$
      } else {
        Response value2 = new Response();
        String text = documentation.getReturnInfo();
        if (!"".equals(text)) { // $NON-NLS-1$
          value2.setDescription(text);
        }
        value.getResponses().put(responseCode, value2); // $NON-NLS-1$
      }
    }
  }
  private void createResponseBuilderInResourceMethodReturnType(
      final JDefinedClass responseClass,
      final int statusCode,
      final Response response,
      final MimeType responseMimeType)
      throws Exception {
    final String responseBuilderMethodName =
        Names.buildResponseMethodName(statusCode, responseMimeType);

    final JMethod responseBuilderMethod =
        responseClass.method(PUBLIC + STATIC, responseClass, responseBuilderMethodName);

    final JDocComment javadoc = responseBuilderMethod.javadoc();

    if (isNotBlank(response.getDescription())) {
      javadoc.add(response.getDescription());
    }

    if ((responseMimeType != null) && (isNotBlank(responseMimeType.getExample()))) {
      javadoc.add(EXAMPLE_PREFIX + responseMimeType.getExample());
    }

    JInvocation builderArgument =
        types
            .getGeneratorClass(javax.ws.rs.core.Response.class)
            .staticInvoke("status")
            .arg(JExpr.lit(statusCode));

    if (responseMimeType != null) {
      builderArgument =
          builderArgument
              .invoke("header")
              .arg(HttpHeaders.CONTENT_TYPE)
              .arg(responseMimeType.getType());
    }

    final StringBuilder freeFormHeadersDescription = new StringBuilder();

    for (final Entry<String, Header> namedHeaderParameter : response.getHeaders().entrySet()) {
      final String headerName = namedHeaderParameter.getKey();
      final Header header = namedHeaderParameter.getValue();

      if (headerName.contains(RESPONSE_HEADER_WILDCARD_SYMBOL)) {
        appendParameterJavadocDescription(header, freeFormHeadersDescription);
        continue;
      }

      final String argumentName = Names.buildVariableName(headerName);

      builderArgument =
          builderArgument.invoke("header").arg(headerName).arg(JExpr.ref(argumentName));

      addParameterJavaDoc(header, argumentName, javadoc);

      responseBuilderMethod.param(types.buildParameterType(header, argumentName), argumentName);
    }

    final JBlock responseBuilderMethodBody = responseBuilderMethod.body();

    final JVar builderVariable =
        responseBuilderMethodBody.decl(
            types.getGeneratorType(ResponseBuilder.class), "responseBuilder", builderArgument);

    if (freeFormHeadersDescription.length() > 0) {
      // generate a Map<String, List<Object>> argument for {?} headers
      final JClass listOfObjectsClass = types.getGeneratorClass(List.class).narrow(Object.class);
      final JClass headersArgument =
          types
              .getGeneratorClass(Map.class)
              .narrow(types.getGeneratorClass(String.class), listOfObjectsClass);

      builderArgument =
          responseBuilderMethodBody
              .invoke("headers")
              .arg(JExpr.ref(MULTIPLE_RESPONSE_HEADERS_ARGUMENT_NAME))
              .arg(builderVariable);

      final JVar param =
          responseBuilderMethod.param(headersArgument, MULTIPLE_RESPONSE_HEADERS_ARGUMENT_NAME);

      javadoc.addParam(param).add(freeFormHeadersDescription.toString());
    }

    if (responseMimeType != null) {
      responseBuilderMethodBody
          .invoke(builderVariable, "entity")
          .arg(JExpr.ref(GENERIC_PAYLOAD_ARGUMENT_NAME));
      responseBuilderMethod.param(
          types.getResponseEntityClass(responseMimeType), GENERIC_PAYLOAD_ARGUMENT_NAME);
      javadoc
          .addParam(GENERIC_PAYLOAD_ARGUMENT_NAME)
          .add(defaultString(responseMimeType.getExample()));
    }

    responseBuilderMethodBody._return(
        JExpr._new(responseClass).arg(builderVariable.invoke("build")));
  }
  private void processResponses(
      IMethodModel m, Action action, IDocInfo documentation, String returnName) {

    HashMap<String, ResponseModel> responses = new HashMap<String, ResponseModel>();
    String mainResponseCode = DEFAULT_RESPONSE;
    if (config != null) {
      ActionType actionType = action.getType();
      mainResponseCode = config.getResponseCode(actionType);
    }

    ResponseModel mainResponse = new ResponseModel(mainResponseCode, null, returnName);
    responses.put(mainResponseCode, mainResponse);

    IAnnotationModel apiResponse = m.getAnnotation(ResourceVisitor.API_RESPONSE);
    if (apiResponse != null) {
      String code = apiResponse.getValue(ResourceVisitor.CODE);
      String message = apiResponse.getValue(ResourceVisitor.MESSAGE);
      ResponseModel response = new ResponseModel(code, message, returnName);
      responses.put(code, response);
    }

    IAnnotationModel apiResponses = m.getAnnotation(ResourceVisitor.API_RESPONSES);
    if (apiResponses != null) {
      IAnnotationModel[] subAnnotations = apiResponses.getSubAnnotations("value");
      if (subAnnotations != null) {
        for (IAnnotationModel subAnn : subAnnotations) {
          String code = subAnn.getValue(ResourceVisitor.CODE);
          String message = subAnn.getValue(ResourceVisitor.MESSAGE);

          String adjustedReturnName = returnName;
          String responseQualifiedName = subAnn.getValue(RESPONSE);
          if (responseQualifiedName != null) {
            try {
              Class<?> responseClass = classLoader.loadClass(responseQualifiedName);
              ReflectionType rt = new ReflectionType(responseClass);
              generateXMLSchema(rt, null);
            } catch (ClassNotFoundException e) {
              e.printStackTrace();
            }
            adjustedReturnName = firstLetterToLowerCase(getSimpleName(responseQualifiedName));
          }
          ResponseModel response = responses.get(code);
          if (response == null) {
            response = new ResponseModel(code, message, adjustedReturnName);
            responses.put(code, response);
          } else {
            response.setMessage(message);
            response.setReturnTypeName(adjustedReturnName);
          }
        }
      }
    }

    String[] producesValues = new String[0];
    ITypeModel returnType = m.getReturnedType();
    if (returnType != null) {
      boolean returnsValue = !returnType.getName().toLowerCase().equals("void");
      producesValues = extractMediaTypes(m, PRODUCES, classProduces, returnsValue, null);
      if (producesValues != null) {
        for (ResponseModel responseModel : responses.values()) {
          responseModel.setProduces(producesValues);
        }
      }
    }
    IAnnotationModel apiOperation = m.getAnnotation(API_OPERATION);
    if (apiOperation != null) {
      String responseContainer = apiOperation.getValue("responseContainer");
      StructureType st = StructureType.COMMON;
      if (responseContainer != null) {
        responseContainer = responseContainer.toLowerCase();
        if (responseContainer.equals("set") || responseContainer.equals("list")) {
          st = StructureType.COLLECTION;
        } else if (responseContainer.equals("map")) {
          st = StructureType.MAP;
        }
      }

      String responseQualifiedName = apiOperation.getValue(RESPONSE);
      if (responseQualifiedName != null) {
        try {
          Class<?> responseClass = classLoader.loadClass(responseQualifiedName);
          ReflectionType rt = new ReflectionType(responseClass);
          generateXMLSchema(rt, st);
        } catch (ClassNotFoundException e) {
          e.printStackTrace();
        }
        String adjustedReturnType = firstLetterToLowerCase(getSimpleName(responseQualifiedName));
        mainResponse.setReturnTypeName(adjustedReturnType);
      }
    }

    for (ResponseModel rm : responses.values()) {

      Response response = new Response();

      String description = rm.getMessage();
      if (description == null || description.trim().isEmpty()) {
        description = documentation.getReturnInfo();
      }
      if (description != null && !description.trim().isEmpty()) {
        response.setDescription(description);
      }

      String[] produces = rm.getProduces();
      if (produces != null) {

        String returnTypeName = rm.getReturnTypeName();
        for (String mediaType : producesValues) {
          mediaType = sanitizeMediaType(mediaType);
          MimeType mimeType = new MimeType();
          tryAppendSchemesAndExamples(mimeType, mediaType, returnTypeName);
          mimeType.setType(mediaType);
          response.getBody().put(mediaType, mimeType);
        }
      }

      String code = rm.getCode();
      action.getResponses().put(code, response);
    }
  }