/*

 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.doclets.formats.html;

import java.io.*;

import java.text.SimpleDateFormat;

import java.util.*;

import com.sun.javadoc.*;

import com.sun.tools.doclets.formats.html.markup.*;

import com.sun.tools.doclets.internal.toolkit.*;

import com.sun.tools.doclets.internal.toolkit.taglets.*;

import com.sun.tools.doclets.internal.toolkit.util.*;

import com.sun.tools.javac.util.StringUtils;

/**

 * Class for the Html Format Code Generation specific to JavaDoc.

 * This Class contains methods related to the Html Code Generation which

 * are used extensively while generating the entire documentation.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 *

 * @since 1.2

 * @author Atul M Dambalkar

 * @author Robert Field

 * @author Bhavesh Patel (Modified)

 */

public class HtmlDocletWriter extends HtmlDocWriter {

    /**

     * Relative path from the file getting generated to the destination

     * directory. For example, if the file getting generated is

     * "java/lang/Object.html", then the path to the root is "../..".

     * This string can be empty if the file getting generated is in

     * the destination directory.

     */

    public final DocPath pathToRoot;

    /**

     * Platform-independent path from the current or the

     * destination directory to the file getting generated.

     * Used when creating the file.

     */

    public final DocPath path;

    /**

     * Name of the file getting generated. If the file getting generated is

     * "java/lang/Object.html", then the filename is "Object.html".

     */

    public final DocPath filename;

    /**

     * The global configuration information for this run.

     */

    public final ConfigurationImpl configuration;

    /**

     * To check whether annotation heading is printed or not.

     */

    protected boolean printedAnnotationHeading = false;

    /**

     * To check whether annotation field heading is printed or not.

     */

    protected boolean printedAnnotationFieldHeading = false;

    /**

     * To check whether the repeated annotations is documented or not.

     */

    private boolean isAnnotationDocumented = false;

    /**

     * To check whether the container annotations is documented or not.

     */

    private boolean isContainerDocumented = false;

    /**

     * Constructor to construct the HtmlStandardWriter object.

     *

     * @param path File to be generated.

     */

    public HtmlDocletWriter(ConfigurationImpl configuration, DocPath path)

            throws IOException {

        super(configuration, path);

        this.configuration = configuration;

        this.path = path;

        this.pathToRoot = path.parent().invert();

        this.filename = path.basename();

    }

    /**

     * Replace {@docRoot} tag used in options that accept HTML text, such

     * as -header, -footer, -top and -bottom, and when converting a relative

     * HREF where commentTagsToString inserts a {@docRoot} where one was

     * missing.  (Also see DocRootTaglet for {@docRoot} tags in doc

     * comments.)

     * <p>

     * Replace {@docRoot} tag in htmlstr with the relative path to the

     * destination directory from the directory where the file is being

     * written, looping to handle all such tags in htmlstr.

     * <p>

     * For example, for "-d docs" and -header containing {@docRoot}, when

     * the HTML page for source file p/C1.java is being generated, the

     * {@docRoot} tag would be inserted into the header as "../",

     * the relative path from docs/p/ to docs/ (the document root).

     * <p>

     * Note: This doc comment was written with '@' representing '@'

     * to prevent the inline tag from being interpreted.

     */

    public String replaceDocRootDir(String htmlstr) {

        // Return if no inline tags exist

        int index = htmlstr.indexOf("{@");

        if (index < 0) {

            return htmlstr;

        }

        String lowerHtml = StringUtils.toLowerCase(htmlstr);

        final String docroot = "{@docroot}";

        // Return index of first occurrence of {@docroot}

        // Note: {@docRoot} is not case sensitive when passed in w/command line option

        index = lowerHtml.indexOf(docroot, index);

        if (index < 0) {

            return htmlstr;

        }

        StringBuilder buf = new StringBuilder();

        int previndex = 0;

        while (true) {

            // Search for lowercase version of {@docRoot}

            index = lowerHtml.indexOf(docroot, previndex);

            // If next {@docRoot} tag not found, append rest of htmlstr and exit loop

            if (index < 0) {

                buf.append(htmlstr.substring(previndex));

                break;

            }

            // If next {@docroot} tag found, append htmlstr up to start of tag

            buf.append(htmlstr.substring(previndex, index));

            previndex = index + docroot.length();

            if (configuration.docrootparent.length() > 0 && htmlstr.startsWith("/..", previndex)) {

                // Insert the absolute link if {@docRoot} is followed by "/..".

                buf.append(configuration.docrootparent);

                previndex += 3;

            } else {

                // Insert relative path where {@docRoot} was located

                buf.append(pathToRoot.isEmpty() ? "." : pathToRoot.getPath());

            }

            // Append slash if next character is not a slash

            if (previndex < htmlstr.length() && htmlstr.charAt(previndex) != '/') {

                buf.append('/');

            }

        }

        return buf.toString();

    }

    /**

     * Get the script to show or hide the All classes link.

     *

     * @param id id of the element to show or hide

     * @return a content tree for the script

     */

    public Content getAllClassesLinkScript(String id) {

        HtmlTree script = new HtmlTree(HtmlTag.SCRIPT);

        script.addAttr(HtmlAttr.TYPE, "text/javascript");

        String scriptCode = "<!--" + DocletConstants.NL +

                "  allClassesLink = document.getElementById(\"" + id + "\");" + DocletConstants.NL +

                "  if(window==top) {" + DocletConstants.NL +

                "    allClassesLink.style.display = \"block\";" + DocletConstants.NL +

                "  }" + DocletConstants.NL +

                "  else {" + DocletConstants.NL +

                "    allClassesLink.style.display = \"none\";" + DocletConstants.NL +

                "  }" + DocletConstants.NL +

                "  //-->" + DocletConstants.NL;

        Content scriptContent = new RawHtml(scriptCode);

        script.addContent(scriptContent);

        Content div = HtmlTree.DIV(script);

        return div;

    }

    /**

     * Add method information.

     *

     * @param method the method to be documented

     * @param dl the content tree to which the method information will be added

     */

    private void addMethodInfo(MethodDoc method, Content dl) {

        ClassDoc[] intfacs = method.containingClass().interfaces();

        MethodDoc overriddenMethod = method.overriddenMethod();

        // Check whether there is any implementation or overridden info to be

        // printed. If no overridden or implementation info needs to be

        // printed, do not print this section.

        if ((intfacs.length > 0 &&

                new ImplementedMethods(method, this.configuration).build().length > 0) ||

                overriddenMethod != null) {

            MethodWriterImpl.addImplementsInfo(this, method, dl);

            if (overriddenMethod != null) {

                MethodWriterImpl.addOverridden(this,

                        method.overriddenType(), overriddenMethod, dl);

            }

        }

    }

    /**

     * Adds the tags information.

     *

     * @param doc the doc for which the tags will be generated

     * @param htmltree the documentation tree to which the tags will be added

     */

    protected void addTagsInfo(Doc doc, Content htmltree) {

        if (configuration.nocomment) {

            return;

        }

        Content dl = new HtmlTree(HtmlTag.DL);

        if (doc instanceof MethodDoc) {

            addMethodInfo((MethodDoc) doc, dl);

        }

        Content output = new ContentBuilder();

        TagletWriter.genTagOuput(configuration.tagletManager, doc,

            configuration.tagletManager.getCustomTaglets(doc),

                getTagletWriterInstance(false), output);

        dl.addContent(output);

        htmltree.addContent(dl);

    }

    /**

     * Check whether there are any tags for Serialization Overview

     * section to be printed.

     *

     * @param field the FieldDoc object to check for tags.

     * @return true if there are tags to be printed else return false.

     */

    protected boolean hasSerializationOverviewTags(FieldDoc field) {

        Content output = new ContentBuilder();

        TagletWriter.genTagOuput(configuration.tagletManager, field,

            configuration.tagletManager.getCustomTaglets(field),

                getTagletWriterInstance(false), output);

        return !output.isEmpty();

    }

    /**

     * Returns a TagletWriter that knows how to write HTML.

     *

     * @return a TagletWriter that knows how to write HTML.

     */

    public TagletWriter getTagletWriterInstance(boolean isFirstSentence) {

        return new TagletWriterImpl(this, isFirstSentence);

    }

    /**

     * Get Package link, with target frame.

     *

     * @param pd The link will be to the "package-summary.html" page for this package

     * @param target name of the target frame

     * @param label tag for the link

     * @return a content for the target package link

     */

    public Content getTargetPackageLink(PackageDoc pd, String target,

            Content label) {

        return getHyperLink(pathString(pd, DocPaths.PACKAGE_SUMMARY), label, "", target);

    }

    /**

     * Get Profile Package link, with target frame.

     *

     * @param pd the packageDoc object

     * @param target name of the target frame

     * @param label tag for the link

     * @param profileName the name of the profile being documented

     * @return a content for the target profile packages link

     */

    public Content getTargetProfilePackageLink(PackageDoc pd, String target,

            Content label, String profileName) {

        return getHyperLink(pathString(pd, DocPaths.profilePackageSummary(profileName)),

                label, "", target);

    }

    /**

     * Get Profile link, with target frame.

     *

     * @param target name of the target frame

     * @param label tag for the link

     * @param profileName the name of the profile being documented

     * @return a content for the target profile link

     */

    public Content getTargetProfileLink(String target, Content label,

            String profileName) {

        return getHyperLink(pathToRoot.resolve(

                DocPaths.profileSummary(profileName)), label, "", target);

    }

    /**

     * Get the type name for profile search.

     *

     * @param cd the classDoc object for which the type name conversion is needed

     * @return a type name string for the type

     */

    public String getTypeNameForProfile(ClassDoc cd) {

        StringBuilder typeName =

                new StringBuilder((cd.containingPackage()).name().replace(".", "/"));

        typeName.append("/")

                .append(cd.name().replace(".", "$"));

        return typeName.toString();

    }

    /**

     * Check if a type belongs to a profile.

     *

     * @param cd the classDoc object that needs to be checked

     * @param profileValue the profile in which the type needs to be checked

     * @return true if the type is in the profile

     */

    public boolean isTypeInProfile(ClassDoc cd, int profileValue) {

        return (configuration.profiles.getProfile(getTypeNameForProfile(cd)) <= profileValue);

    }

    public void addClassesSummary(ClassDoc[] classes, String label,

            String tableSummary, String[] tableHeader, Content summaryContentTree,

            int profileValue) {

        if(classes.length > 0) {

            Arrays.sort(classes);

            Content caption = getTableCaption(new RawHtml(label));

            Content table = HtmlTree.TABLE(HtmlStyle.typeSummary, 0, 3, 0,

                    tableSummary, caption);

            table.addContent(getSummaryTableHeader(tableHeader, "col"));

            Content tbody = new HtmlTree(HtmlTag.TBODY);

            for (int i = 0; i < classes.length; i++) {

                if (!isTypeInProfile(classes[i], profileValue)) {

                    continue;

                }

                if (!Util.isCoreClass(classes[i]) ||

                    !configuration.isGeneratedDoc(classes[i])) {

                    continue;

                }

                Content classContent = getLink(new LinkInfoImpl(

                        configuration, LinkInfoImpl.Kind.PACKAGE, classes[i]));

                Content tdClass = HtmlTree.TD(HtmlStyle.colFirst, classContent);

                HtmlTree tr = HtmlTree.TR(tdClass);

                if (i%2 == 0)

                    tr.addStyle(HtmlStyle.altColor);

                else

                    tr.addStyle(HtmlStyle.rowColor);

                HtmlTree tdClassDescription = new HtmlTree(HtmlTag.TD);

                tdClassDescription.addStyle(HtmlStyle.colLast);

                if (Util.isDeprecated(classes[i])) {

                    tdClassDescription.addContent(deprecatedLabel);

                    if (classes[i].tags("deprecated").length > 0) {

                        addSummaryDeprecatedComment(classes[i],

                            classes[i].tags("deprecated")[0], tdClassDescription);

                    }

                }

                else

                    addSummaryComment(classes[i], tdClassDescription);

                tr.addContent(tdClassDescription);

                tbody.addContent(tr);

            }

            table.addContent(tbody);

            summaryContentTree.addContent(table);

        }

    }

    /**

     * Generates the HTML document tree and prints it out.

     *

     * @param metakeywords Array of String keywords for META tag. Each element

     *                     of the array is assigned to a separate META tag.

     *                     Pass in null for no array

     * @param includeScript true if printing windowtitle script

     *                      false for files that appear in the left-hand frames

     * @param body the body htmltree to be included in the document

     */

    public void printHtmlDocument(String[] metakeywords, boolean includeScript,

            Content body) throws IOException {

        Content htmlDocType = DocType.TRANSITIONAL;

        Content htmlComment = new Comment(configuration.getText("doclet.New_Page"));

        Content head = new HtmlTree(HtmlTag.HEAD);

        head.addContent(getGeneratedBy(!configuration.notimestamp));

        if (configuration.charset.length() > 0) {

            Content meta = HtmlTree.META("Content-Type", CONTENT_TYPE,

                    configuration.charset);

            head.addContent(meta);

        }

        head.addContent(getTitle());

        if (!configuration.notimestamp) {

            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

            Content meta = HtmlTree.META("date", dateFormat.format(new Date()));

            head.addContent(meta);

        }

        if (metakeywords != null) {

                head.addContent(meta);

            }

        }

        head.addContent(getStyleSheetProperties());

        head.addContent(getScriptProperties());

        Content htmlTree = HtmlTree.HTML(configuration.getLocale().getLanguage(),

                head, body);

        Content htmlDocument = new HtmlDocument(htmlDocType,

                htmlComment, htmlTree);

        write(htmlDocument);

    }

    /**

     * Get the window title.

     *

     * @param title the title string to construct the complete window title

     * @return the window title string

     */

    public String getWindowTitle(String title) {

        if (configuration.windowtitle.length() > 0) {

            title += " (" + configuration.windowtitle  + ")";

        }

        return title;

    }

    /**

     * Get user specified header and the footer.

     *

     * @param header if true print the user provided header else print the

     * user provided footer.

     */

    public Content getUserHeaderFooter(boolean header) {

        String content;

        if (header) {

            content = replaceDocRootDir(configuration.header);

        } else {

            if (configuration.footer.length() != 0) {

                content = replaceDocRootDir(configuration.footer);

            } else {

                content = replaceDocRootDir(configuration.header);

            }

        }

        Content rawContent = new RawHtml(content);

        return rawContent;

    }

    /**

     * Adds the user specified top.

     *

     * @param body the content tree to which user specified top will be added

     */

    public void addTop(Content body) {

        Content top = new RawHtml(replaceDocRootDir(configuration.top));

        body.addContent(top);

    }

    /**

     * Adds the user specified bottom.

     *

     * @param body the content tree to which user specified bottom will be added

     */

    public void addBottom(Content body) {

        Content bottom = new RawHtml(replaceDocRootDir(configuration.bottom));

        Content small = HtmlTree.SMALL(bottom);

        Content p = HtmlTree.P(HtmlStyle.legalCopy, small);

        body.addContent(p);

    }

    /**

     * Adds the navigation bar for the Html page at the top and and the bottom.

     *

     * @param header If true print navigation bar at the top of the page else

     * @param body the HtmlTree to which the nav links will be added

     */

    protected void addNavLinks(boolean header, Content body) {

        if (!configuration.nonavbar) {

            String allClassesId = "allclasses_";

            HtmlTree navDiv = new HtmlTree(HtmlTag.DIV);

            Content skipNavLinks = configuration.getResource("doclet.Skip_navigation_links");

            if (header) {

                body.addContent(HtmlConstants.START_OF_TOP_NAVBAR);

                navDiv.addStyle(HtmlStyle.topNav);

                allClassesId += "navbar_top";