/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */
#if !defined(XALAN_STYLESHEETROOT_HEADER_GUARD)
#define XALAN_STYLESHEETROOT_HEADER_GUARD 


// Base include file.  Must be first.
#include "XSLTDefinitions.hpp"


#include "Stylesheet.hpp"


#include <xalanc/Include/XalanMap.hpp>
#include <xalanc/Include/STLHelper.hpp>


#include <xalanc/XalanDOM/XalanDOMString.hpp>


#include <xalanc/PlatformSupport/FormatterListener.hpp>


namespace XALAN_CPP_NAMESPACE {


class ElemAttributeSet;
class StylesheetConstructionContext;
class XalanText;
class XSLTResultTarget;


typedef XalanVector<ElemAttributeSet*>      AttributeSetVectorTypeDecl;
XALAN_USES_MEMORY_MANAGER(AttributeSetVectorTypeDecl)

/**
 * This acts as the stylesheet root of the stylesheet 
 * tree, and holds values that are shared by all 
 * stylesheets in the tree.
 */
class XALAN_XSLT_EXPORT StylesheetRoot : public Stylesheet
{
public:

    typedef XalanVector<const XalanQName*>      XalanQNameVectorType;

    typedef AttributeSetVectorTypeDecl          AttributeSetVectorType;

    typedef XalanMap<const XalanQName*,
                AttributeSetVectorType>         AttributeSetMapType;

    /**
     * Construct a Stylesheet from a Document.
     *
     * @param baseIdentifier document identifier
     * @param constructionContext context for construction of object
     */
    StylesheetRoot(
        const XalanDOMString&           baseIdentifier,
        StylesheetConstructionContext&  constructionContext);    

    virtual 
    ~StylesheetRoot();

    static StylesheetRoot*
    create(
        MemoryManager&              theManager,
        const XalanDOMString&           baseIdentifier,
        StylesheetConstructionContext&  constructionContext);

    MemoryManager&
    getMemoryManager()
    {
        return m_version.getMemoryManager();
    }
    /**
     * Called after construction is completed.
     */
    virtual void
    postConstruction(StylesheetConstructionContext&     constructionContext);

    /**
     * Transform the source tree to the output in the given result tree target.
     *
     * @param inputSource  The input source
     * @param outputTarget The output result target
     * @param constructionContext context for construction of object
     */
    void
    process(
            XalanNode*                      sourceTree,
            XSLTResultTarget&               outputTarget,
            StylesheetExecutionContext&     executionContext) const;

    /**
     * Have the stylesheet create the appropriate FormatterListener,
     * based on the XSLTResultTarget provided.  setupFormatterListener
     * also calls setFormatterListener() on the execution context
     * instance.  setupFormatterListener() is done automatically by
     * process(), but this is provided as an escape, to allow for
     * changing the FormatterListener on-the-fly.
     *
     * @param outputTarget The output source tree
     * @param constructionContext context for construction of object
     * @return a pointer to the new FormatterListener instance.
     */
    FormatterListener*
    setupFormatterListener(
            XSLTResultTarget&               outputTarget,
            StylesheetExecutionContext&     executionContext) const;

    /** 
     * Return the output method that was specified in the stylesheet. 
     * The returned value is one of FormatterLister::eFormat values.
     *
     * @return value of output method
     */
    FormatterListener::eFormat
    getOutputMethod() const
    {
        return m_outputMethod;
    }

    bool
    isOutputMethodSet() const
    {
        return getOutputMethod() == FormatterListener::OUTPUT_METHOD_NONE ? false : true;
    }

    /**
     * Get the output version string that was specified in the
     * xsl:output element
     *
     * @return output version string
     */
    XalanDOMString&
    getOutputVersion(XalanDOMString& theResult) const
    { 
        theResult.assign(m_version);
         
         return theResult;
    }

    /**
     * Determine if output indenting was specified in the
     * xsl:output element
     *
     * @return true to indent
     */
    bool 
    getOutputIndent() const
    {
        return m_indentResult == eIndentNoImplicit ||
               m_indentResult == eIndentNoExplicit ? false : true;
    }

    /**
     * Determine if output indenting should be
     * enabled for HTML output.  Semantically,
     * this implies the output method is implicit,
     * not explicit, but we don't really check that.
     *
     * @return true to indent
     */
    bool 
    getHTMLOutputIndent() const
    {
        return m_indentResult == eIndentNoExplicit ? false : true;
    }

    /**
     * Get the output encoding string that was specified in the
     * xsl:output element
     *
     * @return encoding string
     */
    XalanDOMString& 
    getOutputEncoding(XalanDOMString& theResult) const
    {
        theResult.assign(m_encoding);
        
        return theResult;
    }

    /**
     * Get the media-type string that was specified in the 
     * xsl:output element
     *
     * @return media type string
     */
    XalanDOMString& 
    getOutputMediaType(XalanDOMString& theResult) const
    {
        theResult.assign(m_mediatype);
        
        return theResult;
    }

    /**
     * Get the doctype-system-id string that was specified in the 
     * xsl:output element
     *
     * @return document type string
     */
    XalanDOMString &
    getOutputDoctypeSystem(XalanDOMString& theResult) const
    {
        theResult.assign(m_doctypeSystem);
        
        return theResult;
    }

    /**
     * Get the doctype-public-id string that was specified in the 
     * xsl:output element
     *
     * @return document type public id string
     */
    XalanDOMString& 
    getOutputDoctypePublic(XalanDOMString& theResult) const
    {
        theResult.assign(m_doctypePublic);
        
        return theResult;
    }

    /**
     * Determine whether to output XML declarations.
     *
     * @return true to output declarations
     */
    bool
    getOmitOutputXMLDecl() const
    {
        return m_omitxmlDecl;
    }

    /**
     * Get the standalone string that was specified in the 
     * xsl:output element.(either "yes" or "no")
     *
     * @return standalone string
     */
    XalanDOMString&
    getOutputStandalone(XalanDOMString& theResult) const
    {
        theResult.assign(m_standalone);
        
        return theResult;
    }

    /**
     * Get the template representing the default rule for text.
     *
     * @return pointer to template rule for text
     */
    ElemTemplateElement*
    getDefaultTextRule() const
    {
        return m_defaultTextRule;
    }

    /**
     * Get the template representing the default rule.
     *
     * @return pointer to default template rule
     */
    ElemTemplateElement*
    getDefaultRule() const
    {
        return m_defaultRule;
    }

    /**
     * Get the template representing the default root rule.
     *
     * @return pointer to default root template rule
     */
    ElemTemplateElement*
    getDefaultRootRule() const
    {
        return m_defaultRootRule;
    }

    /**
     * Process the "xsl:output" element.
     *
     * @param name                name of element
     * @param atts                attribute list for element
     * @param constructionContext context for construction of object
     */
    void 
    processOutputSpec(
            const XalanDOMChar*             name, 
            const AttributeListType&        atts,
            StylesheetConstructionContext&  constructionContext);

    /**
     * Retrieve the stack of imported stylesheets.
     * 
     * @return stack of URIs for stylesheets
     */
    URLStackType&
    getImportStack()
    {
        return m_importStack;
    }

    /**
     * Retrieve the stack of imported stylesheets.
     * 
     * @return const stack of URIs for stylesheets
     */
    const URLStackType&
    getImportStack() const
    {
        return m_importStack;
    }

    /**
     * Change the value of the flag for indenting results.
     * 
     * @param bIndent true to indent results
     */
    void
    setIndentResult(bool bIndent)
    {
        m_indentResult = bIndent == true ? eIndentYesExplicit : eIndentNoExplicit;
    }

    /**
     * Change the value of the output method, one of the
     * FormatterListener::eFormat values.
     * 
     * @param meth new method number
     */
    void
    setOutputMethod(FormatterListener::eFormat  meth)
    {
        m_outputMethod = meth;
    }

    bool
    hasCDATASectionElements() const
    {
        assert((m_hasCDATASectionElems == false && m_cdataSectionElems.empty() == true ) ||
              ( m_hasCDATASectionElems == true && m_cdataSectionElems.empty() == false));

        return m_hasCDATASectionElems;
    }

    /**
     * Determine if a QName is in the list of CDATA section
     * element QNames.
     * 
     * @param theQName The QName of the element to check.
     * @return true or false
     */
    bool
    isCDATASectionElementName(const XalanQName&     theQName) const;

    /**
     * Given a valid element key, return the corresponding node list.
     *
     * @param context          context node
     * @param qname            qname of the key, which must match the 'name'
     *                         attribute on xsl:key
     * @param ref              value that must match the value found by the
     *                         'match' attribute on xsl:key
     * @param resolver         resolver for namespace resolution
     * @param nodelist         A node list to contain the nodes found
     * @param executionContext The current execution context
     * @param theKeysTable     The table of keys to search.
     */
    void
    getNodeSetByKey(
            XalanNode*                      context,
            const XalanQName&               qname,
            const XalanDOMString&           ref,
            const PrefixResolver&           resolver,
            MutableNodeRefList&             nodelist,
            StylesheetExecutionContext&     executionContext,
            const Locator*                  locator,
            KeyTablesTableType&             theKeysTable) const;

    unsigned long
    getNextElemNumberID()
    {
        return m_elemNumberNextID++;
    }

    unsigned long
    getElemNumberCount() const
    {
        return m_elemNumberNextID;
    }

    bool
    hasPreserveOrStripSpaceElements() const
    {
        return m_hasStripOrPreserveSpace;
    }

    /**
     * Check to see if a whitespace text node should be stripped from
     * the source tree.
     *
     * @param  theNode The text node to check.
     */
    bool
    shouldStripSourceNode(const XalanText&  theNode) const
    {
        if (hasPreserveOrStripSpaceElements() == true &&
            theNode.isWhitespace() == true)
        {
            return internalShouldStripSourceNode(theNode);
        }

        return false;
    }

    void
    addAttributeSet(ElemAttributeSet&   theAttributeSet);
    
#if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION)
    /**
     * Get the nth attribute set with the specified name.
     *  
     * @param execution     context for executing this stylesheet
     * @param theQName      the name of the attribute set
     * @param matchingIndex index of the attribute set with the specified name
     * @param theLocator    the locator
     * @returns a pointer to the attribute, 0 if no matching attribute set 
     */
    const ElemAttributeSet*
    getAttributeSet(
            StylesheetExecutionContext&     theExecutionContext,
            const XalanQName&               theQName,
            size_type                       matchingIndex,
            const Locator*                  theLocator) const;
#else
    void
    executeAttributeSet(
            StylesheetExecutionContext&     theExecutionContext,
            const XalanQName&               theQName,
            const Locator*                  theLocator) const;
#endif


private:

    /**
     * Choose the encoding to use.
     *
     * @param outputTarget The output result target
     *
     * @return The chosen encoding
     */
    const XalanDOMString&
    getEncoding(const XSLTResultTarget&     outputTarget) const;

    /**
     * Create the default rule if needed.
     *
     * @param constructionContext context for construction of object
     */
    void 
    initDefaultRule(StylesheetConstructionContext&  constructionContext);

    /**
     * Check to see if a whitespace text node should be stripped from
     * the source tree.
     *
     * @param  theNode The text node to check.
     */
    bool
    internalShouldStripSourceNode(const XalanText&  theNode) const;

    /**
     * The version tells the version of XML to be used for outputting the result tree,
     * as specified in xsl:output.
     */
    XalanDOMString  m_version;

    enum eIndentType { eIndentNoImplicit, eIndentNoExplicit, eIndentYesImplicit, eIndentYesExplicit };

    /**
     * indent-result is by default no, which means an XSL processor must not
     * change the whitespace on output.
     */
    eIndentType     m_indentResult;

    /**
     * The encoding attribute specifies the preferred encoding to use 
     * for outputting the result tree. 
     */
    XalanDOMString  m_encoding;

    /**
     * The media-type attribute is applicable for the xml output method. 
     * The default value for the media-type attribute is text/xml.
     */
    XalanDOMString  m_mediatype;

    /**
     * If the doctype-system-id attribute is specified, the xml output method should 
     * output a document type declaration immediately before the first element. 
     * The name following <!DOCTYPE should be the name of the first element. 
     */
    XalanDOMString  m_doctypeSystem;

    /**
     * If doctype-public-id attribute is also specified, then the xml output 
     * method should output PUBLIC followed by the public identifier and then 
     * the system identifier; otherwise, it should output SYSTEM followed by 
     * the system identifier. The internal subset should be empty. The 
     * doctype-public-id attribute should be ignored unless the doctype-system-id 
     * attribute is specified.
     */
    XalanDOMString  m_doctypePublic;

    /**
     * Tells whether or not to output an XML declaration.
     */
    bool            m_omitxmlDecl;

    /**
     * Tells what the xmldecl should specify for the standalone value.
     */
    XalanDOMString  m_standalone;

    /**
     * The URL that belongs to the result namespace.
     * @serial
     */
    XalanDOMString              m_resultNameSpaceURL;

    /**
     * The output method as specified in xsl:output.
     */
    FormatterListener::eFormat  m_outputMethod;

    /**
     * Vector of qnames that specifies elements that should be formatted 
     * as CDATA.
     */
    XalanQNameVectorType        m_cdataSectionElems;

    bool                        m_hasCDATASectionElems;

    /**
     * A stack of who's importing whom is needed in order to detect 
     * a recursive include or import, which is an error.
     */
    URLStackType                m_importStack;


    /**
     * The default template to use for text nodes if we don't find 
     * anything else.  This is initialized in initDefaultRule().
     */
    ElemTemplateElement*        m_defaultTextRule;

    /**
     * The default template to use if we don't find anything
     * else.  This is initialized in initDefaultRule().
     */
    ElemTemplateElement*        m_defaultRule;

    /**
     * The default template to use for the root if we don't find 
     * anything else.  This is initialized in initDefaultRule().
     */
    ElemTemplateElement*        m_defaultRootRule;

    /**
     * This is set to true if an xsl:key directive is found.
     */
    bool                        m_needToBuildKeysTable;

    /**
     * This is set to true if URLs should be escaped in HTML output (the default)
     */
    bool                        m_outputEscapeURLs;

    /**
     * The amount to indent.  The default is -1, which indicates not to indent.
     */
    int                         m_indentAmount;

    /**
     * This is set to true if we should omit the META tag in HTML output (the default is false)
     */
    bool                        m_omitMETATag;

    /**
     * This is set to true if we should omit the META tag in HTML output (the default is false)
     */
    unsigned long               m_elemNumberNextID;

    /**
     * A lookup table of all attribute sets.
     */
    AttributeSetMapType         m_attributeSetsMap;

    /**
     * true if there are any whitespace strip or preserve
     * elements.
     */
    bool                        m_hasStripOrPreserveSpace;


    // Not implemented...
    StylesheetRoot(const StylesheetRoot&);

    StylesheetRoot&
    operator=(const StylesheetRoot&);

    bool
    operator==(const StylesheetRoot&) const;
};


}


#endif  // XALAN_STYLESHEETROOT_HEADER_GUARD