/**
   * Append XML content into root element
   *
   * @param hrefValue href of the topicref
   * @param parentResult XML content to insert into
   * @param tmpContent XML content to insert
   */
  private void insertAfter(String hrefValue, StringBuffer parentResult, CharSequence tmpContent) {
    int insertpoint = parentResult.lastIndexOf("</");
    final int end = parentResult.indexOf(">", insertpoint);

    if (insertpoint == -1 || end == -1) {
      logger.error(MessageUtils.getInstance().getMessage("DOTJ033E", hrefValue).toString());
    } else {
      if (ELEMENT_NAME_DITA.equals(parentResult.substring(insertpoint, end).trim())) {
        insertpoint = parentResult.lastIndexOf("</", insertpoint - 1);
      }
      parentResult.insert(insertpoint, tmpContent);
    }
  }
  private void processChunk(final Element topicref, final File outputFile) {
    final String hrefValue = getValue(topicref, ATTRIBUTE_NAME_HREF);
    final Collection<String> chunkValue = split(getValue(topicref, ATTRIBUTE_NAME_CHUNK));
    final String copytoValue = getValue(topicref, ATTRIBUTE_NAME_COPY_TO);
    final String scopeValue = getCascadeValue(topicref, ATTRIBUTE_NAME_SCOPE);
    final String classValue = getValue(topicref, ATTRIBUTE_NAME_CLASS);
    final String processRoleValue = getCascadeValue(topicref, ATTRIBUTE_NAME_PROCESSING_ROLE);

    File outputFileName = outputFile;
    Writer tempWriter = null;
    Set<String> tempTopicID = null;

    targetTopicId = null;
    selectMethod = CHUNK_SELECT_DOCUMENT;
    include = false;

    boolean needWriteDitaTag = true;

    try {
      String parseFilePath;
      if (copytoValue != null && !chunkValue.contains(CHUNK_TO_CONTENT)) {
        if (getFragment(hrefValue) != null) {
          parseFilePath = setFragment(copytoValue, getFragment(hrefValue));
        } else {
          parseFilePath = copytoValue;
        }
      } else {
        parseFilePath = hrefValue;
      }

      // if @copy-to is processed in chunk module, the list file needs to
      // be updated.
      // Because @copy-to should be included in fulltopiclist, and the
      // source of coyy-to should be excluded in fulltopiclist.
      if (copytoValue != null && chunkValue.contains(CHUNK_TO_CONTENT) && hrefValue != null) {
        copyto.add(copytoValue);
        if (getFragment(hrefValue) != null) {
          copytoSource.add(stripFragment(hrefValue));
          copytotarget2source.put(toURI(copytoValue), toURI(stripFragment(hrefValue)));
        } else {
          copytoSource.add(hrefValue);
          copytotarget2source.put(toURI(copytoValue), toURI(hrefValue));
        }
      }

      if (parseFilePath != null && !ATTR_SCOPE_VALUE_EXTERNAL.equals(scopeValue)) {
        // now the path to target file make sense
        if (chunkValue.contains(CHUNK_TO_CONTENT)) {
          // if current element contains "to-content" in chunk
          // attribute
          // we need to create new buffer and flush the buffer to
          // file
          // after processing is finished
          tempWriter = output;
          tempTopicID = topicID;
          output = new StringWriter();
          topicID = new HashSet<String>();
          if (MAP_MAP.matches(classValue)) {
            // Very special case, we have a map element with
            // href value.
            // This is a map that needs to be chunked to
            // content.
            // No need to parse any file, just generate a stub
            // output.
            outputFileName = resolve(filePath, parseFilePath);
            needWriteDitaTag = false;
          } else if (copytoValue != null) {
            // use @copy-to value as the new file name
            outputFileName = resolve(filePath, copytoValue);
          } else if (hrefValue != null) {
            // try to use href value as the new file name
            if (chunkValue.contains(CHUNK_SELECT_TOPIC)
                || chunkValue.contains(CHUNK_SELECT_BRANCH)) {
              if (getFragment(hrefValue) != null) {
                // if we have an ID here, use it.
                outputFileName = resolve(filePath, getFragment(hrefValue) + FILE_EXTENSION_DITA);
              } else {
                // Find the first topic id in target file if
                // any.
                final String firstTopic = getFirstTopicId(resolve(filePath, hrefValue).getPath());
                if (firstTopic != null) {
                  outputFileName = resolve(filePath, firstTopic + FILE_EXTENSION_DITA);
                } else {
                  outputFileName = resolve(filePath, hrefValue);
                }
              }
            } else {
              // otherwise, use the href value instead
              outputFileName = resolve(filePath, hrefValue);
            }
          } else {
            // use randomly generated file name
            outputFileName = resolve(filePath, generateFilename());
          }

          // Check if there is any conflict
          if (outputFileName.exists() && !MAP_MAP.matches(classValue)) {
            final File t = outputFileName;
            outputFileName = resolve(filePath, generateFilename());
            conflictTable.put(outputFileName.getPath(), t.getPath());
          }
          // add newly generated file to changTable
          // the new entry in changeTable has same key and value
          // in order to indicate it is a newly generated file
          changeTable.put(outputFileName.getPath(), outputFileName.getPath());
        }
        // "by-topic" couldn't reach here
        this.outputFile = outputFileName;

        final String path = resolveTopic(filePath, parseFilePath);
        // FIXME: Should be URI
        String newpath;
        if (getFragment(path) != null) {
          newpath = setFragment(outputFileName.getPath(), getFragment(path));
        } else {
          final String firstTopicID = getFirstTopicId(path);
          if (firstTopicID != null) {
            newpath = setFragment(outputFileName.getPath(), firstTopicID);
          } else {
            newpath = outputFileName.getPath();
          }
        }
        // add file name changes to changeTable, this will be
        // used in
        // TopicRefWriter's updateHref method, very important!!!
        changeTable.put(path, newpath);
        // update current element's @href value
        topicref.setAttribute(
            ATTRIBUTE_NAME_HREF,
            getRelativeUnixPath(filePath + UNIX_SEPARATOR + FILE_NAME_STUB_DITAMAP, newpath));

        if (getFragment(parseFilePath) != null) {
          targetTopicId = getFragment(parseFilePath);
        }

        final String s = getChunkByToken(chunkValue, "select-", null);
        if (s != null) {
          selectMethod = s;
          // if the current topic href referred to a entire
          // topic file,it will be handled in "document" level.
          if (targetTopicId == null) {
            selectMethod = CHUNK_SELECT_DOCUMENT;
          }
        }
        final File tempPath = currentParsingFile;
        currentParsingFile = resolve(filePath, parseFilePath);

        if (!ATTR_PROCESSING_ROLE_VALUE_RESOURCE_ONLY.equals(processRoleValue)) {
          currentParsingFileTopicIDChangeTable = new HashMap<String, String>();
          // TODO recursive point
          reader.parse(currentParsingFile.toURI().toString());
          if (currentParsingFileTopicIDChangeTable.size() > 0) {
            final URI href = toURI(topicref.getAttribute(ATTRIBUTE_NAME_HREF));
            final String pathtoElem = href.getFragment() != null ? href.getFragment() : "";
            final String old_elementid =
                pathtoElem.contains(SLASH)
                    ? pathtoElem.substring(0, pathtoElem.indexOf(SLASH))
                    : pathtoElem;
            if (!old_elementid.isEmpty()) {
              final String new_elementid = currentParsingFileTopicIDChangeTable.get(old_elementid);
              if (new_elementid != null && !new_elementid.isEmpty()) {
                topicref.setAttribute(
                    ATTRIBUTE_NAME_HREF, setFragment(href, new_elementid).toString());
              }
            }
          }
          currentParsingFileTopicIDChangeTable = null;
        }
        // restore the currentParsingFile
        currentParsingFile = tempPath;
      }

      if (topicref.hasChildNodes()) {
        // if current element has child nodes and chunk results for
        // this element has value
        // which means current element makes sense for chunk action.
        final StringWriter tempOutput = (StringWriter) output;
        output = new StringWriter();
        final NodeList children = topicref.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
          final Node current = children.item(i);
          if (MAP_TOPICREF.matches(current)) {
            processChunk((Element) current, outputFileName);
          }
        }

        // merge results
        final StringBuffer parentResult = tempOutput.getBuffer();
        final CharSequence tmpContent = ((StringWriter) output).getBuffer();
        // Skip empty parents and @processing-role='resource-only' entries.
        // append into root topic
        if (parentResult.length() > 0
            && parseFilePath != null
            && !ATTR_PROCESSING_ROLE_VALUE_RESOURCE_ONLY.equals(processRoleValue)) {
          insertAfter(hrefValue, parentResult, tmpContent);
          // replace contents
        } else {
          parentResult.append(tmpContent);
        }
        // restore back to parent's output this is a different temp
        output = tempOutput;
      }

      if (chunkValue.contains(CHUNK_TO_CONTENT)) {
        final String tmpContent = ((StringWriter) output).toString();
        writeToContentChunk(tmpContent, outputFileName, needWriteDitaTag);
        // restore back original output
        output = tempWriter;
        topicID = tempTopicID;
      }
    } catch (final RuntimeException e) {
      throw e;
    } catch (final Exception e) {
      logger.error(e.getMessage(), e);
    }
  }