/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

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

 */

#include <cppuhelper/unourl.hxx>

#include <rtl/malformeduriexception.hxx>

#include <rtl/string.h>

#include <rtl/textenc.h>

#include <rtl/uri.h>

#include <rtl/uri.hxx>

#include <rtl/ustring.hxx>

#include <rtl/character.hxx>

#include <sal/types.h>

#include <map>

#include <memory>

#include <utility>

using cppu::UnoUrl;

using cppu::UnoUrlDescriptor;

class UnoUrlDescriptor::Impl

{

public:

    typedef std::map< OUString, OUString > Parameters;

    OUString m_aDescriptor;

    OUString m_aName;

    Parameters m_aParameters;

    /** @exception rtl::MalformedUriException

     */

    explicit inline Impl(OUString const & m_aDescriptor);

    Impl * clone() const { return new Impl(*this); }

};

inline UnoUrlDescriptor::Impl::Impl(OUString const & rDescriptor)

{

    m_aDescriptor = rDescriptor;

    enum State { STATE_NAME0, STATE_NAME, STATE_KEY0, STATE_KEY, STATE_VALUE };

    State eState = STATE_NAME0;

    sal_Int32 nStart = 0;

    OUString aKey;

    for (sal_Int32 i = 0;; ++i)

    {

        bool bEnd = i == rDescriptor.getLength();

        sal_Unicode c = bEnd ? 0 : rDescriptor[i];

        switch (eState)

        {

        case STATE_NAME0:

            if (bEnd || !rtl::isAsciiAlphanumeric(c))

                throw rtl::MalformedUriException(

                    u"UNO URL contains bad descriptor name"_ustr);

            nStart = i;

            eState = STATE_NAME;

            break;

        case STATE_NAME:

            if (bEnd || c == 0x2C) // ','

            {

                m_aName

                    = rDescriptor.copy(nStart, i - nStart).toAsciiLowerCase();

                eState = STATE_KEY0;

            }

            else if (!rtl::isAsciiAlphanumeric(c))

                throw rtl::MalformedUriException(

                    u"UNO URL contains bad descriptor name"_ustr);

            break;

        case STATE_KEY0:

            if (bEnd || !rtl::isAsciiAlphanumeric(c))

                throw rtl::MalformedUriException(

                    u"UNO URL contains bad parameter key"_ustr);

            nStart = i;

            eState = STATE_KEY;

            break;

        case STATE_KEY:

            if (c == 0x3D) // '='

            {

                aKey = rDescriptor.copy(nStart, i - nStart).toAsciiLowerCase();

                nStart = i + 1;

                eState = STATE_VALUE;

            }

            else if (bEnd || !rtl::isAsciiAlphanumeric(c))

                throw rtl::MalformedUriException(

                    u"UNO URL contains bad parameter key"_ustr);

            break;

        case STATE_VALUE:

            if (bEnd || c == 0x2C) // ','

            {

                if (!m_aParameters.emplace(

                            aKey,

                            rtl::Uri::decode(rDescriptor.copy(nStart,

                                                              i - nStart),

                                             rtl_UriDecodeWithCharset,

                                             RTL_TEXTENCODING_UTF8)).second)

                    throw rtl::MalformedUriException(

                        u"UNO URL contains duplicated parameter"_ustr);

                eState = STATE_KEY0;

            }

            break;

        }

        if (bEnd)

            break;

    }

}

UnoUrlDescriptor::UnoUrlDescriptor(OUString const & rDescriptor):

    m_pImpl(new Impl(rDescriptor))

{}

UnoUrlDescriptor::UnoUrlDescriptor(UnoUrlDescriptor const & rOther):

    m_pImpl(rOther.m_pImpl->clone())

{}

UnoUrlDescriptor::~UnoUrlDescriptor()

{

    delete m_pImpl;

}

UnoUrlDescriptor & UnoUrlDescriptor::operator =(UnoUrlDescriptor const & rOther)

{

    if (this != &rOther)

    {

        std::unique_ptr<Impl> newImpl(rOther.m_pImpl->clone());

        delete m_pImpl;

        m_pImpl = newImpl.release();

    }

    return *this;

}

OUString const & UnoUrlDescriptor::getDescriptor() const

{

    return m_pImpl->m_aDescriptor;

}

OUString const & UnoUrlDescriptor::getName() const

{

    return m_pImpl->m_aName;

}

bool UnoUrlDescriptor::hasParameter(OUString const & rKey) const

{

    return m_pImpl->m_aParameters.find(rKey.toAsciiLowerCase())

        != m_pImpl->m_aParameters.end();

}

OUString UnoUrlDescriptor::getParameter(OUString const & rKey) const

{

    Impl::Parameters::const_iterator

        aIt(m_pImpl->m_aParameters.find(rKey.toAsciiLowerCase()));

    return aIt == m_pImpl->m_aParameters.end() ? OUString() : aIt->second;

}

class UnoUrl::Impl

{

public:

    UnoUrlDescriptor m_aConnection;

    UnoUrlDescriptor m_aProtocol;

    OUString m_aObjectName;

    Impl * clone() const { return new Impl(*this); }

    /** @exception rtl::MalformedUriException

     */

    static inline Impl * create(OUString const & rUrl);

private:

    Impl(OUString const & rConnectionDescriptor,

         OUString const & rProtocolDescriptor,

         OUString aObjectName):

        m_aConnection(rConnectionDescriptor),

        m_aProtocol(rProtocolDescriptor),

        m_aObjectName(std::move(aObjectName))

    {}

};

inline UnoUrl::Impl * UnoUrl::Impl::create(OUString const & rUrl)

{

    if (!rUrl.startsWithIgnoreAsciiCase("uno:"))

        throw rtl::MalformedUriException(u"UNO URL does not start with \"uno:\""_ustr);

    sal_Int32 i = RTL_CONSTASCII_LENGTH("uno:");

    sal_Int32 j = rUrl.indexOf(';', i);

    if (j < 0)

        throw rtl::MalformedUriException(u"UNO URL has too few semicolons"_ustr);

    OUString aConnection(rUrl.copy(i, j - i));

    i = j + 1;

    j = rUrl.indexOf(0x3B, i); // ';'

    if (j < 0)

        throw rtl::MalformedUriException(u"UNO URL has too few semicolons"_ustr);

    OUString aProtocol(rUrl.copy(i, j - i));

    i = j + 1;

    if (i == rUrl.getLength())

        throw rtl::MalformedUriException(u"UNO URL contains empty ObjectName"_ustr);

    for (j = i; j < rUrl.getLength(); ++j)

    {

        sal_Unicode c = rUrl[j];

        if (!rtl::isAsciiAlphanumeric(c) && c != 0x21 && c != 0x24 // '!', '$'

            && c != 0x26 && c != 0x27 && c != 0x28 // '&', ''', '('

            && c != 0x29 && c != 0x2A && c != 0x2B // ')', '*', '+'

            && c != 0x2C && c != 0x2D && c != 0x2E // ',', '-', '.'

            && c != 0x2F && c != 0x3A && c != 0x3D // '/', ':', '='

            && c != 0x3F && c != 0x40 && c != 0x5F // '?', '@', '_'

            && c != 0x7E) // '~'

            throw rtl::MalformedUriException(u"UNO URL contains invalid ObjectName"_ustr);

    }

    return new Impl(aConnection, aProtocol, rUrl.copy(i));

}

UnoUrl::UnoUrl(OUString const & rUrl): m_pImpl(Impl::create(rUrl))

{}

UnoUrl::UnoUrl(UnoUrl const & rOther): m_pImpl(rOther.m_pImpl->clone())

{}

UnoUrl::~UnoUrl()

{

    delete m_pImpl;

}

UnoUrl & UnoUrl::operator =(UnoUrl const & rOther)

{

    if (this != &rOther)

    {

        std::unique_ptr<Impl> newImpl(rOther.m_pImpl->clone());

        delete m_pImpl;

        m_pImpl = newImpl.release();

    }

    return *this;

}

UnoUrlDescriptor const & UnoUrl::getConnection() const

{

    return m_pImpl->m_aConnection;

}

UnoUrlDescriptor const & UnoUrl::getProtocol() const

{

    return m_pImpl->m_aProtocol;

}

OUString const & UnoUrl::getObjectName() const

{

    return m_pImpl->m_aObjectName;

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */