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



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_ucb.hxx"
#include <regexp.hxx>

#include <cstddef>

#include "osl/diagnose.h"
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <rtl/ustrbuf.hxx>
#include <rtl/ustring.hxx>

namespace unnamed_ucb_regexp {} using namespace unnamed_ucb_regexp;
	// unnamed namespaces don't work well yet...

using namespace com::sun::star;
using namespace ucb_impl;

//============================================================================
//
//  Regexp
//
//============================================================================

inline Regexp::Regexp(Kind eTheKind, rtl::OUString const & rThePrefix,
					  bool bTheEmptyDomain, rtl::OUString const & rTheInfix,
					  bool bTheTranslation,
					  rtl::OUString const & rTheReversePrefix):
	m_eKind(eTheKind),
	m_aPrefix(rThePrefix),
	m_aInfix(rTheInfix),
	m_aReversePrefix(rTheReversePrefix),
	m_bEmptyDomain(bTheEmptyDomain),
	m_bTranslation(bTheTranslation)
{
	OSL_ASSERT(m_eKind == KIND_DOMAIN
			   || !m_bEmptyDomain && m_aInfix.getLength() == 0);
	OSL_ASSERT(m_bTranslation || m_aReversePrefix.getLength() == 0);
}

//============================================================================
namespace unnamed_ucb_regexp {

bool matchStringIgnoreCase(sal_Unicode const ** pBegin,
						   sal_Unicode const * pEnd,
						   rtl::OUString const & rString)
{
	sal_Unicode const * p = *pBegin;

	sal_Unicode const * q = rString.getStr();
	sal_Unicode const * qEnd = q + rString.getLength();

	if (pEnd - p < qEnd - q)
		return false;

	while (q != qEnd)
	{
		sal_Unicode c1 = *p++;
		sal_Unicode c2 = *q++;
		if (c1 >= 'a' && c1 <= 'z')
			c1 -= 'a' - 'A';
		if (c2 >= 'a' && c2 <= 'z')
			c2 -= 'a' - 'A';
		if (c1 != c2)
			return false;
	}

	*pBegin = p;
	return true;
}

}

bool Regexp::matches(rtl::OUString const & rString,
					 rtl::OUString * pTranslation, bool * pTranslated) const
{
	sal_Unicode const * pBegin = rString.getStr();
	sal_Unicode const * pEnd = pBegin + rString.getLength();

	bool bMatches = false;

	sal_Unicode const * p = pBegin;
	if (matchStringIgnoreCase(&p, pEnd, m_aPrefix))
	{
		sal_Unicode const * pBlock1Begin = p;
		sal_Unicode const * pBlock1End = pEnd;

		sal_Unicode const * pBlock2Begin = 0;
		sal_Unicode const * pBlock2End = 0;

		switch (m_eKind)
		{
			case KIND_PREFIX:
				bMatches = true;
				break;

			case KIND_AUTHORITY:
				bMatches = p == pEnd || *p == '/' || *p == '?' || *p == '#';
				break;

			case KIND_DOMAIN:
				if (!m_bEmptyDomain)
				{
					if (p == pEnd || *p == '/' || *p == '?' || *p == '#')
						break;
					++p;
				}
				for (;;)
				{
					sal_Unicode const * q = p;
					if (matchStringIgnoreCase(&q, pEnd, m_aInfix)
						&& (q == pEnd || *q == '/' || *q == '?' || *q == '#'))
					{
						bMatches = true;
						pBlock1End = p;
						pBlock2Begin = q;
						pBlock2End = pEnd;
						break;
					}

					if (p == pEnd)
						break;

					sal_Unicode c = *p++;
					if (c == '/' || c == '?' || c == '#')
						break;
				}
				break;
		}

		if (bMatches)
		{
			if (m_bTranslation)
			{
				if (pTranslation)
				{
					rtl::OUStringBuffer aBuffer(m_aReversePrefix);
					aBuffer.append(pBlock1Begin, pBlock1End - pBlock1Begin);
					aBuffer.append(m_aInfix);
					aBuffer.append(pBlock2Begin, pBlock2End - pBlock2Begin);
					*pTranslation = aBuffer.makeStringAndClear();
				}
				if (pTranslated)
					*pTranslated = true;
			}
			else
			{
				if (pTranslation)
					*pTranslation = rString;
				if (pTranslated)
					*pTranslated = false;
			}
		}
	}

	return bMatches;
}

//============================================================================
namespace unnamed_ucb_regexp {

inline bool isAlpha(sal_Unicode c)
{
	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}

inline bool isDigit(sal_Unicode c)
{
	return c >= '0' && c <= '9';
}

bool isScheme(rtl::OUString const & rString, bool bColon)
{
	// Return true if rString matches <scheme> (plus a trailing ":" if bColon
    // is true) from RFC 2396:
	sal_Unicode const * p = rString.getStr();
	sal_Unicode const * pEnd = p + rString.getLength();
	if (p != pEnd && isAlpha(*p))
		for (++p;;)
		{
			if (p == pEnd)
				return !bColon;
			sal_Unicode c = *p++;
			if (!(isAlpha(c) || isDigit(c)
                  || c == '+' || c == '-' || c == '.'))
                return bColon && c == ':' && p == pEnd;
		}
	return false;
}

void appendStringLiteral(rtl::OUStringBuffer * pBuffer,
						 rtl::OUString const & rString)
{
	OSL_ASSERT(pBuffer);

	pBuffer->append(sal_Unicode('"'));
	sal_Unicode const * p = rString.getStr();
	sal_Unicode const * pEnd = p + rString.getLength();
	while (p != pEnd)
	{
		sal_Unicode c = *p++;
		if (c == '"' || c == '\\')
			pBuffer->append(sal_Unicode('\\'));
		pBuffer->append(c);
	}
	pBuffer->append(sal_Unicode('"'));
}

}

rtl::OUString Regexp::getRegexp(bool bReverse) const
{
	if (m_bTranslation)
	{
		rtl::OUStringBuffer aBuffer;
		if (bReverse)
		{
			if (m_aReversePrefix.getLength() != 0)
				appendStringLiteral(&aBuffer, m_aReversePrefix);
		}
		else
		{
			if (m_aPrefix.getLength() != 0)
				appendStringLiteral(&aBuffer, m_aPrefix);
		}
		switch (m_eKind)
		{
			case KIND_PREFIX:
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("(.*)"));
				break;

			case KIND_AUTHORITY:
				aBuffer.
					appendAscii(RTL_CONSTASCII_STRINGPARAM("(([/?#].*)?)"));
				break;

			case KIND_DOMAIN:
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("([^/?#]"));
				aBuffer.append(sal_Unicode(m_bEmptyDomain ? '*' : '+'));
				if (m_aInfix.getLength() != 0)
					appendStringLiteral(&aBuffer, m_aInfix);
				aBuffer.
					appendAscii(RTL_CONSTASCII_STRINGPARAM("([/?#].*)?)"));
				break;
		}
		aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("->"));
		if (bReverse)
		{
			if (m_aPrefix.getLength() != 0)
				appendStringLiteral(&aBuffer, m_aPrefix);
		}
		else
		{
			if (m_aReversePrefix.getLength() != 0)
				appendStringLiteral(&aBuffer, m_aReversePrefix);
		}
		aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("\\1"));
		return aBuffer.makeStringAndClear();
	}
	else if (m_eKind == KIND_PREFIX && isScheme(m_aPrefix, true))
		return m_aPrefix.copy(0, m_aPrefix.getLength() - 1);
	else
	{
		rtl::OUStringBuffer aBuffer;
		if (m_aPrefix.getLength() != 0)
			appendStringLiteral(&aBuffer, m_aPrefix);
		switch (m_eKind)
		{
			case KIND_PREFIX:
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM(".*"));
				break;

			case KIND_AUTHORITY:
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("([/?#].*)?"));
				break;

			case KIND_DOMAIN:
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("[^/?#]"));
				aBuffer.append(sal_Unicode(m_bEmptyDomain ? '*' : '+'));
				if (m_aInfix.getLength() != 0)
					appendStringLiteral(&aBuffer, m_aInfix);
				aBuffer.appendAscii(RTL_CONSTASCII_STRINGPARAM("([/?#].*)?"));
				break;
		}
		return aBuffer.makeStringAndClear();
	}
}

//============================================================================
namespace unnamed_ucb_regexp {

bool matchString(sal_Unicode const ** pBegin, sal_Unicode const * pEnd,
				 sal_Char const * pString, size_t nStringLength)
{
	sal_Unicode const * p = *pBegin;

	sal_uChar const * q = reinterpret_cast< sal_uChar const * >(pString);
	sal_uChar const * qEnd = q + nStringLength;

	if (pEnd - p < qEnd - q)
		return false;

	while (q != qEnd)
	{
		sal_Unicode c1 = *p++;
		sal_Unicode c2 = *q++;
		if (c1 != c2)
			return false;
	}

	*pBegin = p;
	return true;
}

bool scanStringLiteral(sal_Unicode const ** pBegin, sal_Unicode const * pEnd,
					   rtl::OUString * pString)
{
	sal_Unicode const * p = *pBegin;

	if (p == pEnd || *p++ != '"')
		return false;

	rtl::OUStringBuffer aBuffer;
	for (;;)
	{
		if (p == pEnd)
			return false;
		sal_Unicode c = *p++;
		if (c == '"')
			break;
		if (c == '\\')
		{
			if (p == pEnd)
				return false;
			c = *p++;
			if (c != '"' && c != '\\')
				return false;
		}
		aBuffer.append(c);
	}

	*pBegin = p;
	*pString = aBuffer.makeStringAndClear();
	return true;
}

}

Regexp Regexp::parse(rtl::OUString const & rRegexp)
{
	// Detect an input of '<scheme>' as an abbreviation of '"<scheme>:".*'
	// where <scheme> is as defined in RFC 2396:
	if (isScheme(rRegexp, false))
		return Regexp(Regexp::KIND_PREFIX,
                      rRegexp
                          + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(":")),
                      false,
                      rtl::OUString(),
					  false,
                      rtl::OUString());

	sal_Unicode const * p = rRegexp.getStr();
	sal_Unicode const * pEnd = p + rRegexp.getLength();

	rtl::OUString aPrefix;
	scanStringLiteral(&p, pEnd, &aPrefix);

	if (p == pEnd)
		throw lang::IllegalArgumentException();

	if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM(".*")))
	{
		if (p != pEnd)
			throw lang::IllegalArgumentException();

		return Regexp(Regexp::KIND_PREFIX, aPrefix, false, rtl::OUString(),
					  false, rtl::OUString());
	}
	else if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("(.*)->")))
	{
		rtl::OUString aReversePrefix;
		scanStringLiteral(&p, pEnd, &aReversePrefix);

		if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))
			|| p != pEnd)
			throw lang::IllegalArgumentException();

		return Regexp(Regexp::KIND_PREFIX, aPrefix, false, rtl::OUString(),
					  true, aReversePrefix);
	}
	else if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("([/?#].*)?")))
	{
		if (p != pEnd)
			throw lang::IllegalArgumentException();

		return Regexp(Regexp::KIND_AUTHORITY, aPrefix, false, rtl::OUString(),
					  false, rtl::OUString());
	}
	else if (matchString(&p, pEnd,
						 RTL_CONSTASCII_STRINGPARAM("(([/?#].*)?)->")))
	{
		rtl::OUString aReversePrefix;
		if (!(scanStringLiteral(&p, pEnd, &aReversePrefix)
			  && matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))
			  && p == pEnd))
			throw lang::IllegalArgumentException();

		return Regexp(Regexp::KIND_AUTHORITY, aPrefix, false, rtl::OUString(),
					  true, aReversePrefix);
	}
	else
	{
		bool bOpen = false;
		if (p != pEnd && *p == '(')
		{
			++p;
			bOpen = true;
		}

		if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("[^/?#]")))
			throw lang::IllegalArgumentException();

		if (p == pEnd || (*p != '*' && *p != '+'))
			throw lang::IllegalArgumentException();
		bool bEmptyDomain = *p++ == '*';

		rtl::OUString aInfix;
		scanStringLiteral(&p, pEnd, &aInfix);

		if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("([/?#].*)?")))
			throw lang::IllegalArgumentException();

		rtl::OUString aReversePrefix;
		if (bOpen
			&& !(matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM(")->"))
				 && scanStringLiteral(&p, pEnd, &aReversePrefix)
				 && matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))))
			throw lang::IllegalArgumentException();

		if (p != pEnd)
			throw lang::IllegalArgumentException();

		return Regexp(Regexp::KIND_DOMAIN, aPrefix, bEmptyDomain, aInfix,
					  bOpen, aReversePrefix);
	}
}