/*

 * Copyright (c) 1998, 2012, 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.*;

/**

 * 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 relative path string is "../../".

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

     * the destination directory.

     */

    public String relativePath = "";

    /**

     * Same as relativepath, but normalized to never be empty or

     * end with a slash.

     */

    public String relativepathNoSlash = "";

    /**

     * Platform-dependent directory path from the current or the

     * destination directory to the file getting generated.

     * Used when creating the file.

     * For example, if the file getting generated is

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

     */

    public String path = "";

    /**

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

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

     */

    public String filename = "";

    /**

     * The display length used for indentation while generating the class page.

     */

    public int displayLength = 0;

    /**

     * The global configuration information for this run.

     */

    public ConfigurationImpl configuration;

    /**

     * To check whether annotation heading is printed or not.

     */

    protected boolean printedAnnotationHeading = false;

    /**

     * Constructor to construct the HtmlStandardWriter object.

     *

     * @param filename File to be generated.

     */

    public HtmlDocletWriter(ConfigurationImpl configuration,

                              String filename) throws IOException {

        super(configuration, filename);

        this.configuration = configuration;

        this.filename = filename;

    }

    /**

     * Constructor to construct the HtmlStandardWriter object.

     *

     * @param path         Platform-dependent {@link #path} used when

     *                     creating file.

     * @param filename     Name of file to be generated.

     * @param relativePath Value for the variable {@link #relativePath}.

     */

    public HtmlDocletWriter(ConfigurationImpl configuration,

                              String path, String filename,

                              String relativePath) throws IOException {

        super(configuration, path, filename);

        this.configuration = configuration;

        this.path = path;

        this.relativePath = relativePath;

        this.relativepathNoSlash =

            DirectoryManager.getPathNoTrailingSlash(this.relativePath);

        this.filename = filename;

    }

    /**

     * 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 = htmlstr.toLowerCase();

        // 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) {

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

                // Search for lowercase version of {@docRoot}/..

                index = lowerHtml.indexOf("{@docroot}/..", previndex);

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

                if (index < 0) {

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

                    break;

                }

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

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

                previndex = index + 13;  // length for {@docroot}/.. string

                // Insert docrootparent absolute path where {@docRoot}/.. was located

                buf.append(configuration.docrootparent);

                // Append slash if next character is not a slash

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

                    buf.append(DirectoryManager.URL_FILE_SEPARATOR);

                }

            } else {

                // 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 + 10;  // length for {@docroot} string

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

                buf.append(relativepathNoSlash);

                // Append slash if next character is not a slash

                if (relativepathNoSlash.length() > 0 && previndex < htmlstr.length() &&

                        htmlstr.charAt(previndex) != '/') {

                    buf.append(DirectoryManager.URL_FILE_SEPARATOR);

                }

            }

        }

        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);

        }

        TagletOutputImpl output = new TagletOutputImpl("");

        TagletWriter.genTagOuput(configuration.tagletManager, doc,

            configuration.tagletManager.getCustomTags(doc),

                getTagletWriterInstance(false), output);

        String outputString = output.toString().trim();

        if (!outputString.isEmpty()) {

            Content resultString = new RawHtml(outputString);

            dl.addContent(resultString);

        }

        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) {

        TagletOutputImpl output = new TagletOutputImpl("");

        TagletWriter.genTagOuput(configuration.tagletManager, field,

            configuration.tagletManager.getCustomTags(field),

                getTagletWriterInstance(false), output);

        return (!output.toString().trim().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, "package-summary.html"), "", label, "", target);

    }

    /**

     * 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);

        if (!configuration.notimestamp) {

            Content headComment = new Comment(getGeneratedByString());

            head.addContent(headComment);

        }

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

            Content meta = HtmlTree.META("Content-Type", "text/html",

                    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) {

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

                Content meta = HtmlTree.META("keywords", metakeywords[i]);

                head.addContent(meta);

            }

        }

        head.addContent(getStyleSheetProperties());

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

                head, body);

        Content htmlDocument = new HtmlDocument(htmlDocType,

                htmlComment, htmlTree);

    }

    /**

     * 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);

        Content em = HtmlTree.EM(rawContent);

        return em;

    }

    /**

     * 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);

            if (header) {

                body.addContent(HtmlConstants.START_OF_TOP_NAVBAR);

                navDiv.addStyle(HtmlStyle.topNav);

                allClassesId += "navbar_top";

                Content a = getMarkerAnchor("navbar_top");

                navDiv.addContent(a);

                Content skipLinkContent = getHyperLink("",

                        "skip-navbar_top", HtmlTree.EMPTY, configuration.getText(

                        "doclet.Skip_navigation_links"), "");

                navDiv.addContent(skipLinkContent);

            } else {

                body.addContent(HtmlConstants.START_OF_BOTTOM_NAVBAR);

                navDiv.addStyle(HtmlStyle.bottomNav);

                allClassesId += "navbar_bottom";

                Content a = getMarkerAnchor("navbar_bottom");

                navDiv.addContent(a);

                Content skipLinkContent = getHyperLink("",

                        "skip-navbar_bottom", HtmlTree.EMPTY, configuration.getText(

                        "doclet.Skip_navigation_links"), "");

                navDiv.addContent(skipLinkContent);

            }

            if (header) {

                navDiv.addContent(getMarkerAnchor("navbar_top_firstrow"));

            } else {

                navDiv.addContent(getMarkerAnchor("navbar_bottom_firstrow"));

            }

            HtmlTree navList = new HtmlTree(HtmlTag.UL);

            navList.addStyle(HtmlStyle.navList);

            navList.addAttr(HtmlAttr.TITLE, "Navigation");

            if (configuration.createoverview) {

                navList.addContent(getNavLinkContents());

            }

            if (configuration.packages.length == 1) {

                navList.addContent(getNavLinkPackage(configuration.packages[0]));

            } else if (configuration.packages.length > 1) {

                navList.addContent(getNavLinkPackage());

            }

            navList.addContent(getNavLinkClass());

            if(configuration.classuse) {

                navList.addContent(getNavLinkClassUse());

            }

            if(configuration.createtree) {

                navList.addContent(getNavLinkTree());

            }

            if(!(configuration.nodeprecated ||

                     configuration.nodeprecatedlist)) {

                navList.addContent(getNavLinkDeprecated());

            }

            if(configuration.createindex) {

                navList.addContent(getNavLinkIndex());

            }

            if (!configuration.nohelp) {

                navList.addContent(getNavLinkHelp());

            }

            navDiv.addContent(navList);

            Content aboutDiv = HtmlTree.DIV(HtmlStyle.aboutLanguage, getUserHeaderFooter(header));

            navDiv.addContent(aboutDiv);

            body.addContent(navDiv);

            Content ulNav = HtmlTree.UL(HtmlStyle.navList, getNavLinkPrevious());

            ulNav.addContent(getNavLinkNext());

            Content subDiv = HtmlTree.DIV(HtmlStyle.subNav, ulNav);

            Content ulFrames = HtmlTree.UL(HtmlStyle.navList, getNavShowLists());

            ulFrames.addContent(getNavHideLists(filename));

            subDiv.addContent(ulFrames);

            HtmlTree ulAllClasses = HtmlTree.UL(HtmlStyle.navList, getNavLinkClassIndex());

            ulAllClasses.addAttr(HtmlAttr.ID, allClassesId.toString());

            subDiv.addContent(ulAllClasses);

            subDiv.addContent(getAllClassesLinkScript(allClassesId.toString()));

            addSummaryDetailLinks(subDiv);

            if (header) {

                subDiv.addContent(getMarkerAnchor("skip-navbar_top"));

                body.addContent(subDiv);

                body.addContent(HtmlConstants.END_OF_TOP_NAVBAR);

            } else {

                subDiv.addContent(getMarkerAnchor("skip-navbar_bottom"));