/*
 * Copyright 2006 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.doctool;

import com.google.doctool.LinkResolver.ExtraClassResolver;

import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.ConstructorDoc;
import com.sun.javadoc.Doc;
import com.sun.javadoc.DocErrorReporter;
import com.sun.javadoc.ExecutableMemberDoc;
import com.sun.javadoc.FieldDoc;
import com.sun.javadoc.MemberDoc;
import com.sun.javadoc.MethodDoc;
import com.sun.javadoc.PackageDoc;
import com.sun.javadoc.ParamTag;
import com.sun.javadoc.Parameter;
import com.sun.javadoc.ProgramElementDoc;
import com.sun.javadoc.RootDoc;
import com.sun.javadoc.SeeTag;
import com.sun.javadoc.SourcePosition;
import com.sun.javadoc.Tag;
import com.sun.javadoc.Type;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Stack;

/**
 * Generates XML from Javadoc source, with particular idioms to make it possible
 * to translate into either expository doc or API doc.
 */
public class Booklet {

  private static final String OPT_BKCODE = "-bkcode";
  private static final String OPT_BKDOCPKG = "-bkdocpkg";
  private static final String OPT_BKOUT = "-bkout";

  private static Booklet sBooklet;

  public static void main(String[] args) {
    // Strip off our arguments at the beginning.
    //
    com.sun.tools.javadoc.Main.execute(args);
  }

  public static int optionLength(String option) {
    if (option.equals(OPT_BKOUT)) {
      return 2;
    } else if (option.equals(OPT_BKDOCPKG)) {
      return 2;
    } else if (option.equals(OPT_BKCODE)) {
      return 1;
    }
    return 0;
  }

  public static String slurpSource(SourcePosition position) {
    BufferedReader br = null;
    try {
      br = new BufferedReader(new FileReader(position.file()));
      for (int i = 0, n = position.line() - 1; i < n; ++i) {
        br.readLine();
      }

      StringBuffer lines = new StringBuffer();
      String line = br.readLine();
      int braceDepth = 0;
      int indent = -1;
      boolean seenSemiColonOrBrace = false;
      while (line != null) {
        if (indent == -1) {
          for (indent = 0; Character.isWhitespace(line.charAt(indent)); ++indent) {
            // just accumulate
          }
        }

        if (line.length() >= indent) {
          line = line.substring(indent);
        }

        lines.append(line + "\n");
        for (int i = 0, n = line.length(); i < n; ++i) {
          char c = line.charAt(i);
          if (c == '{') {
            seenSemiColonOrBrace = true;
            ++braceDepth;
          } else if (c == '}') {
            --braceDepth;
          } else if (c == ';') {
            seenSemiColonOrBrace = true;
          }
        }

        if (braceDepth > 0 || !seenSemiColonOrBrace) {
          line = br.readLine();
        } else {
          break;
        }
      }

      String code = lines.toString();
      return code;
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        if (br != null) {
          br.close();
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return "";
  }

  public static boolean start(RootDoc rootDoc) {
    getBooklet().process(rootDoc);
    return true;
  }

  public static boolean validOptions(String[][] options,
      DocErrorReporter reporter) {
    return getBooklet().analyzeOptions(options, reporter);
  }

  private static Booklet getBooklet() {
    if (sBooklet == null) {
      sBooklet = new Booklet();
    }
    return sBooklet;
  }

  private String outputPath;

  private HashSet packagesToGenerate;

  private RootDoc initialRootDoc;

  private String rootDocId;

  private boolean showCode;

  private HashSet standardTagKinds = new HashSet();

  private Stack tagStack = new Stack();

  private PrintWriter pw;

  public Booklet() {
    // Set up standard tags (to ignore during tag processing)
    //
    standardTagKinds.add("@see");
    standardTagKinds.add("@serial");
    standardTagKinds.add("@throws");
    standardTagKinds.add("@param");
    standardTagKinds.add("@id");
  }

  private boolean analyzeOptions(String[][] options, DocErrorReporter reporter) {
    for (int i = 0, n = options.length; i < n; ++i) {
      if (options[i][0].equals(OPT_BKOUT)) {
        outputPath = options[i][1];
      } else if (options[i][0].equals(OPT_BKDOCPKG)) {
        String[] packages = options[i][1].split(";");
        packagesToGenerate = new HashSet();
        for (int packageIndex = 0; packageIndex < packages.length; ++packageIndex) {
          packagesToGenerate.add(packages[packageIndex]);
        }
      } else if (options[i][0].equals(OPT_BKCODE)) {
        showCode = true;
      }
    }

    if (outputPath == null) {
      reporter.printError("You must specify an output directory with "
          + OPT_BKOUT);
      return false;
    }

    return true;
  }

  private void begin(String tag) {
    pw.print("<" + tag + ">");
    tagStack.push(tag);
  }

  private void begin(String tag, String attr, String value) {
    pw.print("<" + tag + " " + attr + "='" + value + "'>");
    tagStack.push(tag);
  }

  private void beginCDATA() {
    pw.print("<![CDATA[");
  }

  private void beginEndln(String tag) {
    pw.println("<" + tag + "/>");
  }

  private void beginln(String tag) {
    pw.println();
    begin(tag);
  }

  private void beginln(String tag, String attr, String value) {
    pw.println();
    begin(tag, attr, value);
  }

  private void emitDescription(ClassDoc enclosing, Doc forWhat,
      Tag[] leadInline, Tag[] descInline) {
    emitJRELink(enclosing, forWhat);

    beginln("lead");
    processTags(leadInline);
    endln();

    beginln("description");
    processTags(descInline);
    endln();
  }

  private void emitIdentity(String id, String name) {
    beginln("id");
    text(id);
    endln();

    beginln("name");
    text(name);
    endln();
  }

  private void emitJRELink(ClassDoc enclosing, Doc doc) {
    String jreLink = "http://java.sun.com/j2se/1.5.0/docs/api/";
    if (doc instanceof ClassDoc) {
      ClassDoc classDoc = (ClassDoc) doc;
      String pkg = classDoc.containingPackage().name();
      if (!pkg.startsWith("java.")) {
        return;
      }
      String clazz = classDoc.name();

      jreLink += pkg.replace('.', '/') + "/";
      jreLink += clazz;
      jreLink += ".html";
    } else if (doc instanceof ExecutableMemberDoc) {
      ExecutableMemberDoc execMemberDoc = (ExecutableMemberDoc) doc;
      String pkg = enclosing.containingPackage().name();
      if (!pkg.startsWith("java.")) {
        return;
      }
      String clazz = enclosing.name();
      String method = execMemberDoc.name();
      String sig = execMemberDoc.signature();

      jreLink += pkg.replace('.', '/') + "/";
      jreLink += clazz;
      jreLink += ".html";
      jreLink += "#";
      jreLink += method;
      jreLink += sig;
    } else if (doc instanceof PackageDoc) {
      String pkg = doc.name();
      if (!pkg.startsWith("java.")) {
        return;
      }
      jreLink += pkg.replace('.', '/') + "/package-summary.html";
    } else if (doc instanceof FieldDoc) {
      FieldDoc fieldDoc = (FieldDoc) doc;
      String pkg = enclosing.containingPackage().name();
      if (!pkg.startsWith("java.")) {
        return;
      }
      String clazz = fieldDoc.containingClass().name();
      String field = fieldDoc.name();

      jreLink += pkg.replace('.', '/') + "/";
      jreLink += clazz;
      jreLink += ".html";
      jreLink += "#";
      jreLink += field;
    }

    // Add the link.
    //
    beginln("jre");
    text(jreLink);
    endln();
  }

  private void emitLocation(Doc doc) {
    Doc parent = getParentDoc(doc);
    if (parent != null) {
      beginln("location");
      emitLocationLink(parent);
      endln();
    }
  }

  private void emitLocationLink(Doc doc) {
    // Intentionally reverses the order.
    //
    String myId;
    String myTitle;
    if (doc instanceof MemberDoc) {
      MemberDoc memberDoc = (MemberDoc) doc;
      myId = getId(memberDoc);
      myTitle = memberDoc.name();
    } else if (doc instanceof ClassDoc) {
      ClassDoc classDoc = (ClassDoc) doc;
      myId = getId(classDoc);
      myTitle = classDoc.name();
    } else if (doc instanceof PackageDoc) {
      PackageDoc pkgDoc = (PackageDoc) doc;
      myId = getId(pkgDoc);
      myTitle = pkgDoc.name();
    } else if (doc instanceof RootDoc) {
      myId = rootDocId;
      myTitle = initialRootDoc.name();
    } else {
      throw new IllegalStateException(
          "Expected only a member, type, or package");
    }

    Doc parent = getParentDoc(doc);
    if (parent != null) {
      emitLocationLink(parent);
    }

    beginln("link", "ref", myId);

    Tag[] titleTag = doc.tags("@title");
    if (titleTag.length > 0) {
      myTitle = titleTag[0].text().trim();
    }

    if (myTitle == null || myTitle.length() == 0) {
      myTitle = "[NO TITLE]";
    }

    text(myTitle);

    endln();
  }

  private void emitModifiers(ProgramElementDoc doc) {
    if (doc.isPrivate()) {
      beginEndln("isPrivate");
    } else if (doc.isProtected()) {
      beginEndln("isProtected");
    } else if (doc.isPublic()) {
      beginEndln("isPublic");
    } else if (doc.isPackagePrivate()) {
      beginEndln("isPackagePrivate");
    }

    if (doc.isStatic()) {
      beginEndln("isStatic");
    }

    if (doc.isFinal()) {
      beginEndln("isFinal");
    }

    if (doc instanceof MethodDoc) {
      MethodDoc methodDoc = (MethodDoc) doc;

      if (methodDoc.isAbstract()) {
        beginEndln("isAbstract");
      }

      if (methodDoc.isSynchronized()) {
        beginEndln("isSynchronized");
      }
    }
  }

  private void emitOutOfLineTags(Tag[] tags) {
    beginln("tags");
    processTags(tags);
    endln();
  }

  private void emitType(Type type) {
    ClassDoc typeAsClass = type.asClassDoc();

    if (typeAsClass != null) {
      begin("type", "ref", getId(typeAsClass));
    } else {
      begin("type");
    }

    String typeName = type.typeName();
    String dims = type.dimension();

    text(typeName + dims);

    end();
  }

  private void end() {
    pw.print("</" + tagStack.pop() + ">");
  }

  private void endCDATA() {
    pw.print("]]>");
  }

  private void endln() {
    end();
    pw.println();
  }

  private MethodDoc findMatchingInterfaceMethodDoc(ClassDoc[] interfaces,
      MethodDoc methodDoc) {
    if (interfaces != null) {
      // Look through the methods on superInterface for a matching methodDoc.
      //
      for (int intfIndex = 0; intfIndex < interfaces.length; ++intfIndex) {
        ClassDoc currentIntfDoc = interfaces[intfIndex];
        MethodDoc[] intfMethodDocs = currentIntfDoc.methods();
        for (int methodIndex = 0; methodIndex < intfMethodDocs.length; ++methodIndex) {
          MethodDoc intfMethodDoc = intfMethodDocs[methodIndex];
          String methodDocName = methodDoc.name();
          String intfMethodDocName = intfMethodDoc.name();
          if (methodDocName.equals(intfMethodDocName)) {
            if (methodDoc.signature().equals(intfMethodDoc.signature())) {
              // It's a match!
              //
              return intfMethodDoc;
            }
          }
        }

        // Try the superinterfaces of this interface.
        //
        MethodDoc foundMethodDoc = findMatchingInterfaceMethodDoc(
            currentIntfDoc.interfaces(), methodDoc);
        if (foundMethodDoc != null) {
          return foundMethodDoc;
        }
      }
    }

    // Just didn't find it anywhere. Must not be based on an implemented
    // interface.
    //
    return null;
  }

  private ExtraClassResolver getExtraClassResolver(Tag tag) {

    if (tag.holder() instanceof PackageDoc) {
      return new ExtraClassResolver() {
        public ClassDoc findClass(String className) {
          return initialRootDoc.classNamed(className);
        }
      };
    }

    return null;
  }

  private String getId(ClassDoc classDoc) {
    return classDoc.qualifiedName();
  }

  private String getId(ExecutableMemberDoc memberDoc) {
    // Use the mangled name to look up a unique id (based on its hashCode).
    //
    String clazz = memberDoc.containingClass().qualifiedName();
    String id = clazz + "#" + memberDoc.name() + memberDoc.signature();
    return id;
  }

  private String getId(FieldDoc fieldDoc) {
    String clazz = fieldDoc.containingClass().qualifiedName();
    String id = clazz + "#" + fieldDoc.name();
    return id;
  }

  private String getId(MemberDoc memberDoc) {
    if (memberDoc.isMethod()) {
      return getId((MethodDoc) memberDoc);
    } else if (memberDoc.isConstructor()) {
      return getId((ConstructorDoc) memberDoc);
    } else if (memberDoc.isField()) {
      return getId((FieldDoc) memberDoc);
    } else {
      throw new RuntimeException("Unknown member type");
    }
  }

  private String getId(PackageDoc packageDoc) {
    return packageDoc.name();
  }

  private Doc getParentDoc(Doc doc) {
    if (doc instanceof MemberDoc) {
      MemberDoc memberDoc = (MemberDoc) doc;
      return memberDoc.containingClass();
    } else if (doc instanceof ClassDoc) {
      ClassDoc classDoc = (ClassDoc) doc;
      Doc enclosingClass = classDoc.containingClass();
      if (enclosingClass != null) {
        return enclosingClass;
      } else {
        return classDoc.containingPackage();
      }
    } else if (doc instanceof PackageDoc) {
      return initialRootDoc;
    } else if (doc instanceof RootDoc) {
      return null;
    } else {
      throw new IllegalStateException(
          "Expected only a member, type, or package");
    }
  }

  private boolean looksSynthesized(ExecutableMemberDoc memberDoc) {
    SourcePosition memberPos = memberDoc.position();
    int memberLine = memberPos.line();

    SourcePosition classPos = memberDoc.containingClass().position();
    int classLine = classPos.line();

    if (memberLine == classLine) {
      return true;
    } else {
      return false;
    }
  }

  private void process(ClassDoc enclosing, ClassDoc classDoc) {
    // Make sure it isn't a @skip-ped topic.
    //
    if (classDoc.tags("@skip").length > 0) {
      // This one is explicitly skipped right now.
      //
      return;
    }

    if (classDoc.isInterface()) {
      beginln("interface");
    } else {
      beginln("class");
    }

    emitIdentity(getId(classDoc), classDoc.name());
    emitLocation(classDoc);
    emitDescription(enclosing, classDoc, classDoc.firstSentenceTags(),
        classDoc.inlineTags());
    emitOutOfLineTags(classDoc.tags());
    emitModifiers(classDoc);

    ClassDoc superclassDoc = classDoc.superclass();
    if (superclassDoc != null) {
      beginln("superclass", "ref", getId(superclassDoc));
      text(superclassDoc.name());
      endln();
    }

    ClassDoc[] superinterfacesDoc = classDoc.interfaces();
    for (int i = 0; i < superinterfacesDoc.length; i++) {
      ClassDoc superinterfaceDoc = superinterfacesDoc[i];
      beginln("superinterface", "ref", getId(superinterfaceDoc));
      text(superinterfaceDoc.name());
      endln();
    }

    ClassDoc[] cda = classDoc.innerClasses();
    for (int i = 0; i < cda.length; i++) {
      process(classDoc, cda[i]);
    }

    FieldDoc[] fda = classDoc.fields();
    for (int i = 0; i < fda.length; i++) {
      process(classDoc, fda[i]);
    }

    ConstructorDoc[] ctorDocs = classDoc.constructors();
    for (int i = 0; i < ctorDocs.length; i++) {
      process(classDoc, ctorDocs[i]);
    }

    MethodDoc[] methods = classDoc.methods();
    for (int i = 0; i < methods.length; i++) {
      process(classDoc, methods[i]);
    }

    endln();
  }

  private void process(ClassDoc enclosing, ExecutableMemberDoc memberDoc) {
    if (looksSynthesized(memberDoc)) {
      // Skip it.
      //
      return;
    }

    // Make sure it isn't a @skip-ped member.
    //
    if (memberDoc.tags("@skip").length > 0) {
      // This one is explicitly skipped right now.
      //
      return;
    }

    if (memberDoc instanceof MethodDoc) {
      beginln("method");
      emitIdentity(getId(memberDoc), memberDoc.name());
      emitLocation(memberDoc);

      // If this method is not explicitly documented, use the best inherited
      // one.
      //
      String rawComment = memberDoc.getRawCommentText();
      if (rawComment.length() == 0) {
        // Switch out the member doc being used.
        //
        MethodDoc methodDoc = (MethodDoc) memberDoc;
        MethodDoc superMethodDoc = methodDoc.overriddenMethod();

        if (superMethodDoc == null) {

          ClassDoc classDocToTry = methodDoc.containingClass();
          while (classDocToTry != null) {
            // See if this is a method from an interface.
            // If so, borrow its description.
            //
            superMethodDoc = findMatchingInterfaceMethodDoc(
                classDocToTry.interfaces(), methodDoc);

            if (superMethodDoc != null) {
              break;
            }

            classDocToTry = classDocToTry.superclass();
          }
        }

        if (superMethodDoc != null) {
          // Borrow the description from the superclass/superinterface.
          //
          memberDoc = superMethodDoc;
        }
      }
    } else if (memberDoc instanceof ConstructorDoc) {
      beginln("constructor");
      emitIdentity(getId(memberDoc), memberDoc.containingClass().name());
      emitLocation(memberDoc);
    } else {
      throw new IllegalStateException("What kind of executable member is this?");
    }

    emitDescription(enclosing, memberDoc, memberDoc.firstSentenceTags(),
        memberDoc.inlineTags());
    emitOutOfLineTags(memberDoc.tags());
    emitModifiers(memberDoc);

    begin("flatSignature");
    text(memberDoc.flatSignature());
    end();

    // Return type if it's a method
    //
    if (memberDoc instanceof MethodDoc) {
      emitType(((MethodDoc) memberDoc).returnType());
    }

    // Parameters
    //
    beginln("params");
    Parameter[] pda = memberDoc.parameters();
    for (int i = 0; i < pda.length; i++) {
      Parameter pd = pda[i];

      begin("param");
      emitType(pd.type());
      begin("name");
      text(pd.name());
      end();
      end();
    }
    endln();

    // Exceptions thrown
    //
    ClassDoc[] tea = memberDoc.thrownExceptions();
    if (tea.length > 0) {
      beginln("throws");
      for (int i = 0; i < tea.length; ++i) {
        ClassDoc te = tea[i];
        beginln("throw", "ref", getId(te));
        text(te.name());
        endln();
      }
      endln();
    }

    // Maybe show code
    //
    if (showCode) {
      SourcePosition pos = memberDoc.position();
      if (pos != null) {
        beginln("code");
        String source = slurpSource(pos);
        begin("pre", "class", "code");
        beginCDATA();
        text(source);
        endCDATA();
        endln();
        endln();
      }
    }

    endln();
  }

  private void process(ClassDoc enclosing, FieldDoc fieldDoc) {
    // Make sure it isn't @skip-ped.
    //
    if (fieldDoc.tags("@skip").length > 0) {
      // This one is explicitly skipped right now.
      //
      return;
    }

    String commentText = fieldDoc.commentText();
    if (fieldDoc.isPrivate()
        && (commentText == null || commentText.length() == 0)) {
      return;
    }

    beginln("field");
    emitIdentity(fieldDoc.qualifiedName(), fieldDoc.name());
    emitLocation(fieldDoc);
    emitDescription(enclosing, fieldDoc, fieldDoc.firstSentenceTags(),
        fieldDoc.inlineTags());
    emitOutOfLineTags(fieldDoc.tags());
    emitModifiers(fieldDoc);
    emitType(fieldDoc.type());
    endln();
  }

  private void process(PackageDoc packageDoc) {
    beginln("package");

    emitIdentity(packageDoc.name(), packageDoc.name());
    emitLocation(packageDoc);
    emitDescription(null, packageDoc, packageDoc.firstSentenceTags(),
        packageDoc.inlineTags());
    emitOutOfLineTags(packageDoc.tags());

    // Top-level classes
    //
    ClassDoc[] cda = packageDoc.allClasses();
    for (int i = 0; i < cda.length; i++) {
      ClassDoc cd = cda[i];

      // Make sure we have source.
      //
      SourcePosition p = cd.position();
      if (p == null || p.line() == 0) {
        // Skip this since it isn't ours (otherwise we would have source).
        //
        continue;
      }

      if (cd.containingClass() == null) {
        process(cd, cda[i]);
      } else {
        // Not a top-level class.
        //
        cd = cda[i];
      }
    }

    endln();
  }

  private void process(RootDoc rootDoc) {
    try {
      initialRootDoc = rootDoc;
      File outputFile = new File(outputPath);
      // Ignore result since the next line will fail if the directory doesn't
      // exist.
      outputFile.getParentFile().mkdirs();
      FileWriter fw = new FileWriter(outputFile);
      pw = new PrintWriter(fw, true);

      beginln("booklet");

      rootDocId = "";
      String title = "";
      Tag[] idTags = rootDoc.tags("@id");
      if (idTags.length > 0) {
        rootDocId = idTags[0].text();
      } else {
        initialRootDoc.printWarning("Expecting @id in an overview html doc; see -overview");
      }

      Tag[] titleTags = rootDoc.tags("@title");
      if (titleTags.length > 0) {
        title = titleTags[0].text();
      } else {
        initialRootDoc.printWarning("Expecting @title in an overview html doc; see -overview");
      }

      emitIdentity(rootDocId, title);
      emitLocation(rootDoc);
      emitDescription(null, rootDoc, rootDoc.firstSentenceTags(),
          rootDoc.inlineTags());
      emitOutOfLineTags(rootDoc.tags());

      // Create a list of the packages to iterate over.
      //
      HashSet packageNames = new HashSet();
      ClassDoc[] cda = initialRootDoc.classes();
      for (int i = 0; i < cda.length; i++) {
        ClassDoc cd = cda[i];
        // Only top-level classes matter.
        //
        if (cd.containingClass() == null) {
          packageNames.add(cd.containingPackage().name());
        }
      }

      // Packages
      //
      for (Iterator iter = packageNames.iterator(); iter.hasNext();) {
        String packageName = (String) iter.next();

        // Only process this package if either no "docpkg" is set, or it is
        // included.
        //
        if (packagesToGenerate == null
            || packagesToGenerate.contains(packageName)) {
          PackageDoc pd = initialRootDoc.packageNamed(packageName);
          process(pd);
        }
      }

      endln();
    } catch (Exception e) {
      e.printStackTrace();
      initialRootDoc.printError("Caught exception: " + e.toString());
    }
  }

  private void processSeeTag(SeeTag seeTag) {
    String ref = null;
    ClassDoc cd = null;
    PackageDoc pd = null;
    MemberDoc md = null;
    String title = null;

    // Check for HTML links
    if (seeTag.text().startsWith("<")) {
      // TODO: ignore for now
      return;
    }
    // Ordered: most-specific to least-specific
    if (null != (md = seeTag.referencedMember())) {
      ref = getId(md);
    } else if (null != (cd = seeTag.referencedClass())) {
      ref = getId(cd);

      // See if the target has a title.
      //
      Tag[] titleTag = cd.tags("@title");
      if (titleTag.length > 0) {
        title = titleTag[0].text().trim();
        if (title.length() == 0) {
          title = null;
        }
      }
    } else if (null != (pd = seeTag.referencedPackage())) {
      ref = getId(pd);
    }

    String label = seeTag.label();

    // If there is a label, use it.
    if (label == null || label.trim().length() == 0) {

      // If there isn't a label, see if the @see target has a @title.
      //
      if (title != null) {
        label = title;
      } else {
        label = seeTag.text();

        if (label.endsWith(".")) {
          label = label.substring(0, label.length() - 1);
        }

        // Rip off all but the last interesting part to prevent fully-qualified
        // names everywhere.
        //
        int last1 = label.lastIndexOf('.');
        int last2 = label.lastIndexOf('#');

        if (last2 > last1) {
          // Use the class name plus the member name.
          //
          label = label.substring(last1 + 1).replace('#', '.');
        } else if (last1 != -1) {
          label = label.substring(last1 + 1);
        }

        if (label.charAt(0) == '.') {
          // Started with "#" so remove the dot.
          //
          label = label.substring(1);
        }
      }
    }

    if (ref != null) {
      begin("link", "ref", ref);
      text(label != null ? label.trim() : "");
      end();
    } else {
      initialRootDoc.printWarning(seeTag.position(),
          "Unverifiable cross-reference to '" + seeTag.text() + "'");
      // The link probably won't work, but emit it anyway.
      begin("link");
      text(label != null ? label.trim() : "");
      end();
    }
  }

  private void processTags(Tag[] tags) {
    for (int i = 0; i < tags.length; i++) {
      Tag tag = tags[i];
      String tagKind = tag.kind();
      if (tagKind.equals("Text")) {
        text(tag.text());
      } else if (tagKind.equals("@see")) {
        processSeeTag((SeeTag) tag);
      } else if (tagKind.equals("@param")) {
        ParamTag paramTag = (ParamTag) tag;
        beginln("param");
        begin("name");
        text(paramTag.parameterName());
        end();
        begin("description");
        processTags(paramTag.inlineTags());
        end();
        endln();
      } else if (tagKind.equals("@example")) {
        ExtraClassResolver extraClassResolver = getExtraClassResolver(tag);
        SourcePosition pos = LinkResolver.resolveLink(tag, extraClassResolver);
        String source = slurpSource(pos);
        begin("pre", "class", "code");
        beginCDATA();
        text(source);
        endCDATA();
        endln();
      } else if (tagKind.equals("@gwt.include")) {
        String contents = ResourceIncluder.getResourceFromClasspathScrubbedForHTML(tag);
        begin("pre", "class", "code");
        text(contents);
        endln();
      } else if (!standardTagKinds.contains(tag.name())) {
        // Custom tag; pass it along other tag.
        //
        String tagName = tag.name().substring(1);
        begin(tagName);
        processTags(tag.inlineTags());
        end();
      }
    }
  }

  private void text(String s) {
    pw.print(s);
  }
}