/*
 * 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.
 */


#include "XalanParsedURI.hpp"


#include "DOMStringHelper.hpp"
#include "XalanUnicode.hpp"


XALAN_CPP_NAMESPACE_BEGIN


#if defined(XALAN_INLINE_INITIALIZATION) && !defined(XALAN_INLINE_INITIALIZATION_IS_DEFINITION_BUG)
const int   XalanParsedURI::d_scheme;
const int   XalanParsedURI::d_authority;
const int   XalanParsedURI::d_query;
const int   XalanParsedURI::d_fragment;
#endif


/* Merge the components back into a complete URI string */
XalanDOMString& XalanParsedURI::make(XalanDOMString&        uri) const
{
    uri.erase();

    if (m_defined & d_scheme)
    {
        uri += m_scheme;
        uri += XalanUnicode::charColon;
    }
    if (m_defined & d_authority)
    {
        uri += XalanUnicode::charSolidus;
        uri += XalanUnicode::charSolidus;
        uri += m_authority;
    }
    uri += m_path;
    if (m_defined & d_query)
    {
        uri += XalanUnicode::charQuestionMark;
        uri += m_query;
    }
    if (m_defined & d_fragment)
    {
        uri += XalanUnicode::charNumberSign;
        uri += m_fragment;
    }
    return uri;
}

/* Parse a URI into component parts.
   Essentially implements the regex ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 */
void XalanParsedURI::parse(
    const XalanDOMChar*         uriString,
    XalanDOMString::size_type   uriStringLen
)
{
    XalanDOMString::size_type index = 0;
    
    // Clear the components present mask
    m_defined = 0;

    // Scheme portion
    while (index < uriStringLen && 
                uriString[index] != XalanUnicode::charColon && 
                uriString[index] != XalanUnicode::charSolidus && 
                uriString[index] != XalanUnicode::charQuestionMark && 
                uriString[index] != XalanUnicode::charNumberSign)
    {
        ++index;
    }
    
    if (index > 0 && uriString[index] == XalanUnicode::charColon)
    {
        m_scheme = XalanDOMString(uriString, getMemoryManager(), index);
        ++index;
        m_defined |= d_scheme;
    }
    else
    {
        index = 0;
        m_scheme.clear();
    }

    // Authority portion
    if (index < uriStringLen - 1 &&
        uriString[index] == XalanUnicode::charSolidus && 
        uriString[index+1] == XalanUnicode::charSolidus) 
    {
        index += 2;
        XalanDOMString::size_type authority = index;

        while (index < uriStringLen &&
                uriString[index] != XalanUnicode::charSolidus && 
                uriString[index] != XalanUnicode::charQuestionMark && 
                uriString[index] != XalanUnicode::charNumberSign)
        {
            ++index;
        }
        if (index != authority)
        {
            m_authority = XalanDOMString(uriString + authority, getMemoryManager(), index - authority);
            m_defined |= d_authority;
        }
        else
            m_authority.clear();
    }
    else
    {
        m_authority.clear();
    }

    // Path portion
    XalanDOMString::size_type path = index;
    while (index < uriStringLen &&
            uriString[index] != XalanUnicode::charQuestionMark && 
            uriString[index] != XalanUnicode::charNumberSign)
    {
        ++index;
    }
    m_path = XalanDOMString(uriString + path,getMemoryManager(), index - path);

    // Query portion
    if (index < uriStringLen && uriString[index] == XalanUnicode::charQuestionMark)
    {
        ++index;
        XalanDOMString::size_type query = index;

        while (index < uriStringLen &&
                uriString[index] != XalanUnicode::charNumberSign)
        {
            ++index;
        }
        m_query = XalanDOMString(uriString + query,getMemoryManager(), index - query);
        m_defined |= d_query;
    }
    else
    {
        m_query.clear();
    }

    // Fragment portion
    if (index < uriStringLen && uriString[index] == XalanUnicode::charNumberSign)
    {
        ++index;
        m_fragment = XalanDOMString(uriString + index, getMemoryManager(), uriStringLen - index);
        m_defined |= d_fragment;
    }
    else
    {
        m_fragment.clear();
    }
}

/* Resolve this URI relative to another according to RFC2396, section 5.2 */
void XalanParsedURI::resolve(
    const XalanParsedURI &base
)
{
    if (base.isSchemeDefined() == false)
    {
        // Protect against a base URI that is relative...
        // This might become an assert or an exception.
    }
    // Handle references to the current document (step 2)
    else if ((m_defined & (d_scheme | d_authority | d_query)) == 0 &&
        m_path.empty())
    {
        m_defined = base.m_defined;
        if (base.m_defined & d_scheme)
            m_scheme    = base.m_scheme;
        if (base.m_defined & d_authority)
            m_authority = base.m_authority;

        m_path      = base.m_path;

        if (base.m_defined & d_query)
            m_query     = base.m_query;

        // There is an error/unclarity in the specification in step 2 in that
        // it doesn't state that the fragment should be inherited; however
        // it is clear from the examples that it should be
        if (!(m_defined & d_fragment))
        {
            m_fragment = base.m_fragment;
        }

        m_defined |= base.m_defined;
    }
    // A defined scheme component implies that this is an absolute URI (step 3)
    // Also allow a scheme without authority that matches the base scheme to be 
    // interpreted as a relative URI
    else if (!(m_defined & d_scheme) || ( 
            (base.m_defined & d_scheme) && !(m_defined & d_authority) 
            && equalsIgnoreCaseASCII(m_scheme, base.m_scheme)))
    {
        // Inherit the base scheme
        if (base.m_defined & d_scheme)
        {
            m_scheme = base.m_scheme;
            m_defined |= d_scheme;
        }

        // Step 4: If the authority is unm_defined then inherit it, otherwise skip to step 7
        if (!(m_defined & d_authority))
        {
            // Inherit the base authority
            if (base.m_defined & d_authority)
            {
                m_authority = base.m_authority;
                m_defined |= d_authority;
            }

            // Step 5: if the path starts with a / then it is absolute
            if (!(m_path.length() > 0 && m_path[0] == XalanUnicode::charSolidus))
            {
                // Step 6: merge relative path components

                // a) strip off characters after the right most slash in the base path
                XalanDOMString::size_type pathEnd = base.m_path.length();
                while (pathEnd > 0 && base.m_path[pathEnd - 1] != XalanUnicode::charSolidus)
                {
                    --pathEnd;
                }

                if (pathEnd > 0) 
                {
                    // b) append relative path
                    // This inserts the path portion from base...
                    m_path.insert(0, base.m_path, 0, pathEnd);
                }
                else
                {
                    // TODO, maybe raise an error here as this
                    // is a severely wonky looking URI
                }

                // c)->g remove various "./" and "../" segments
                for (XalanDOMString::size_type index = 0; index < m_path.length(); ) 
                {
                    // remove '<segment>/../' and ./
                    if (m_path[index] == XalanUnicode::charFullStop) 
                    {
                        if (index < m_path.length()-1 && 
                            m_path[index+1] == XalanUnicode::charSolidus) // ./
                        {
                            m_path.erase(index,2);
                            continue;
                        } 
                        else if (index == m_path.length()-1) // trailing /.
                        {
                            m_path.erase(index,1);
                            continue;
                        } 
                        // Note: also strips leading ../ in an attempt to get 
                        // something out of a bad m_path
                        else if (index < m_path.length()-2 && 
                                    m_path[index+1] == XalanUnicode::charFullStop && 
                                    m_path[index+2] == XalanUnicode::charSolidus) // ../
                        { 
                            const XalanDOMString::size_type     end = index + 2;
                            if (index > 0) --index;
                            for ( ; index > 0 && m_path[index-1] != XalanUnicode::charSolidus; index--) 
                                ;
                            if (index > 0) --index;
                            m_path.erase(index, end - index);
                            continue;
                        } 
                        else if (index == m_path.length()-2 && 
                                    m_path[index+1] == XalanUnicode::charFullStop) // trailing /..
                        {
                            const XalanDOMString::size_type     end = index + 2;
                            if (index > 0) --index;
                            for ( ; index > 0 && m_path[index-1] != XalanUnicode::charSolidus; index--) 
                                ;
                            m_path.erase(index, end - index);
                            continue;
                        }
                    }
                    for ( ; index < m_path.length() && m_path[index] != XalanUnicode::charSolidus ; ++index)
                    {
                    }
                    ++index;
                }
            }
        }
    }
}

/* Static helper function to perform a resolve without mucking about with this class */
XalanDOMString& XalanParsedURI::resolve(
    const XalanDOMChar          *relative,
    XalanDOMString::size_type   relativeLen,
    const XalanDOMChar          *base,
    XalanDOMString::size_type   baseLen,
    XalanDOMString&             theResult
)
{
    XalanParsedURI relativeURI(relative, relativeLen, theResult.getMemoryManager());
    XalanParsedURI baseURI(base, baseLen, theResult.getMemoryManager());

    relativeURI.resolve(baseURI);
    return relativeURI.make(theResult);
}

XALAN_CPP_NAMESPACE_END