/**************************************************************
 * 
 * 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 "precompiled_formula.hxx"

#include "formula/formulahelper.hxx"
#include <unotools/charclass.hxx>
#include <unotools/syslocale.hxx>

namespace formula
{

    namespace 
    {
        //============================================================================
        class OEmptyFunctionDescription : public IFunctionDescription
        {
        public:
            OEmptyFunctionDescription(){}
            virtual ~OEmptyFunctionDescription(){}

            virtual ::rtl::OUString getFunctionName() const { return ::rtl::OUString(); }
            virtual const IFunctionCategory* getCategory() const { return NULL; }
            virtual ::rtl::OUString getDescription() const { return ::rtl::OUString(); }
            virtual xub_StrLen getSuppressedArgumentCount() const { return 0; }
            virtual ::rtl::OUString getFormula(const ::std::vector< ::rtl::OUString >& ) const { return ::rtl::OUString(); }
            virtual void fillVisibleArgumentMapping(::std::vector<sal_uInt16>& ) const {}
            virtual void initArgumentInfo()  const {}
            virtual ::rtl::OUString getSignature() const { return ::rtl::OUString(); }
            virtual rtl::OString getHelpId() const { return ""; }
            virtual sal_uInt32 getParameterCount() const { return 0; }
            virtual ::rtl::OUString getParameterName(sal_uInt32 ) const { return ::rtl::OUString(); }
            virtual ::rtl::OUString getParameterDescription(sal_uInt32 ) const { return ::rtl::OUString(); }
            virtual bool isParameterOptional(sal_uInt32 ) const { return sal_False; }
        };
    }
//===================================================================
//	class FormulaHelper - statische Methoden
//===================================================================

#define FUNC_NOTFOUND 0xffff

FormulaHelper::FormulaHelper(const IFunctionManager* _pFunctionManager) 
    :m_pSysLocale(new SvtSysLocale)
    ,m_pFunctionManager(_pFunctionManager)
    ,open(_pFunctionManager->getSingleToken(IFunctionManager::eOk))
    ,close(_pFunctionManager->getSingleToken(IFunctionManager::eClose))
    ,sep(_pFunctionManager->getSingleToken(IFunctionManager::eSep))
    ,arrayOpen(_pFunctionManager->getSingleToken(IFunctionManager::eArrayOpen))
    ,arrayClose(_pFunctionManager->getSingleToken(IFunctionManager::eArrayClose))
{
    m_pCharClass = m_pSysLocale->GetCharClassPtr();
}
sal_Bool FormulaHelper::GetNextFunc( const String&	rFormula,
								 sal_Bool			bBack,
								 xub_StrLen&	rFStart,   // Ein- und Ausgabe
								 xub_StrLen*	pFEnd, 	   // = NULL
								 const IFunctionDescription**	ppFDesc,   // = NULL
                                 ::std::vector< ::rtl::OUString>*	pArgs )  const // = NULL
{
	sal_Bool		bFound = sal_False;
	xub_StrLen	nOldStart = rFStart;
	String		aFname;

	rFStart = GetFunctionStart( rFormula, rFStart, bBack, ppFDesc ? &aFname : NULL );
	bFound  = ( rFStart != FUNC_NOTFOUND );

	if ( bFound )
	{
		if ( pFEnd )
			*pFEnd = GetFunctionEnd( rFormula, rFStart );

		if ( ppFDesc )
		{
            *ppFDesc = NULL;
            const ::rtl::OUString sTemp( aFname );
            const sal_uInt32 nCategoryCount = m_pFunctionManager->getCount();
            for(sal_uInt32 j= 0; j < nCategoryCount && !*ppFDesc; ++j)
            {
                const IFunctionCategory* pCategory = m_pFunctionManager->getCategory(j);
                const sal_uInt32 nCount = pCategory->getCount();
                for(sal_uInt32 i = 0 ; i < nCount; ++i)
                {
                    const IFunctionDescription* pCurrent = pCategory->getFunction(i);
	                if ( pCurrent->getFunctionName().equalsIgnoreAsciiCase(sTemp) )
                    {
                        *ppFDesc = pCurrent;
                        break;
                    }
                } // for(sal_uInt32 i = 0 ; i < nCount; ++i)
            }
			if ( *ppFDesc && pArgs )
			{
				GetArgStrings( *pArgs,rFormula, rFStart, static_cast<sal_uInt16>((*ppFDesc)->getParameterCount() ));
			}
            else
            {
                static OEmptyFunctionDescription s_aFunctionDescription;
                *ppFDesc = &s_aFunctionDescription;
            }
		}
	}
	else
		rFStart = nOldStart;

	return bFound;
}

//------------------------------------------------------------------------

void FormulaHelper::FillArgStrings( const String&	rFormula,
									xub_StrLen		nFuncPos,
									sal_uInt16			nArgs,
									::std::vector< ::rtl::OUString >& _rArgs ) const
{
	xub_StrLen	nStart	= 0;
	xub_StrLen	nEnd	= 0;
	sal_uInt16		i;
	sal_Bool		bLast	= sal_False;

	for ( i=0; i<nArgs && !bLast; i++ )
	{
		nStart = GetArgStart( rFormula, nFuncPos, i );

		if ( i+1<nArgs ) // letztes Argument?
		{
			nEnd = GetArgStart( rFormula, nFuncPos, i+1 );

			if ( nEnd != nStart )
                _rArgs.push_back(rFormula.Copy( nStart, nEnd-1-nStart ));
			else
				_rArgs.push_back(String()), bLast = sal_True;
		}
		else
		{
			nEnd = GetFunctionEnd( rFormula, nFuncPos )-1;
			if ( nStart < nEnd )
				_rArgs.push_back( rFormula.Copy( nStart, nEnd-nStart ) );
			else
				_rArgs.push_back(String());
		}
	}

	if ( bLast )
		for ( ; i<nArgs; i++ )
			_rArgs.push_back(String());
}

//------------------------------------------------------------------------

void FormulaHelper::GetArgStrings( ::std::vector< ::rtl::OUString >& _rArgs
                                      ,const String& rFormula,
									   xub_StrLen nFuncPos,
									   sal_uInt16 nArgs ) const
{
	if (nArgs)
	{
		FillArgStrings( rFormula, nFuncPos, nArgs, _rArgs );
	}
}

//------------------------------------------------------------------------

inline sal_Bool IsFormulaText( const CharClass* _pCharClass,const String& rStr, xub_StrLen nPos )
{
	if( _pCharClass->isLetterNumeric( rStr, nPos ) )
		return sal_True;
	else
	{	// In internationalized versions function names may contain a dot
		//  and in every version also an underscore... ;-)
		sal_Unicode c = rStr.GetChar(nPos);
		return c == '.' || c == '_';
	}

}

xub_StrLen FormulaHelper::GetFunctionStart( const String&	rFormula,
										xub_StrLen		nStart,
										sal_Bool			bBack,
										String*			pFuncName ) const
{
	xub_StrLen nStrLen = rFormula.Len();

	if ( nStrLen < nStart )
		return nStart;

	xub_StrLen	nFStart = FUNC_NOTFOUND;
	xub_StrLen	nParPos	= nStart;

	sal_Bool bRepeat, bFound;
	do
	{
		bFound  = sal_False;
		bRepeat = sal_False;

		if ( bBack )
		{
			while ( !bFound && (nParPos > 0) )
			{
				if ( rFormula.GetChar(nParPos) == '"' )
				{
					nParPos--;
					while ( (nParPos > 0) && rFormula.GetChar(nParPos) != '"' )
						nParPos--;
					if (nParPos > 0)
						nParPos--;
				}
                else if ( (bFound = ( rFormula.GetChar(nParPos) == '(' ) ) == sal_False )
					nParPos--;
			}
		}
		else
		{
			while ( !bFound && (nParPos < nStrLen) )
			{
				if ( rFormula.GetChar(nParPos) == '"' )
				{
					nParPos++;
					while ( (nParPos < nStrLen) && rFormula.GetChar(nParPos) != '"' )
						nParPos++;
					nParPos++;
				}
                else if ( (bFound = ( rFormula.GetChar(nParPos) == '(' ) ) == sal_False )
					nParPos++;
			}
		}

		if ( bFound && (nParPos > 0) )
		{
			nFStart = nParPos-1;

			while ( (nFStart > 0) && IsFormulaText(m_pCharClass, rFormula, nFStart ))
				nFStart--;
		}

		nFStart++;

		if ( bFound )
		{
			if ( IsFormulaText( m_pCharClass,rFormula, nFStart ) )
			{
									//	Funktion gefunden
				if ( pFuncName )
					*pFuncName = rFormula.Copy( nFStart, nParPos-nFStart );
			}
			else					// Klammern ohne Funktion -> weitersuchen
			{
				bRepeat = sal_True;
				if ( !bBack )
					nParPos++;
				else if (nParPos > 0)
					nParPos--;
				else
					bRepeat = sal_False;
			}
		}
		else						// keine Klammern gefunden
		{
			nFStart = FUNC_NOTFOUND;
			if ( pFuncName )
				pFuncName->Erase();
		}
	}
	while(bRepeat);

	return nFStart;
}

//------------------------------------------------------------------------

xub_StrLen	FormulaHelper::GetFunctionEnd( const String& rStr, xub_StrLen nStart ) const
{
	xub_StrLen nStrLen = rStr.Len();

	if ( nStrLen < nStart )
		return nStart;

	short	nParCount = 0;
    bool    bInArray = false;
	sal_Bool	bFound = sal_False;

	while ( !bFound && (nStart < nStrLen) )
	{
		sal_Unicode c = rStr.GetChar(nStart);

		if ( c == '"' )
		{
			nStart++;
			while ( (nStart < nStrLen) && rStr.GetChar(nStart) != '"' )
				nStart++;
		}
		else if ( c == open )
			nParCount++;
		else if ( c == close )
		{
			nParCount--;
			if ( nParCount == 0 )
				bFound = sal_True;
			else if ( nParCount < 0 )
			{
				bFound = sal_True;
				nStart--;	// einen zu weit gelesen
			}
		}
        else if ( c == arrayOpen )
        {
            bInArray = true;
        }
        else if ( c == arrayClose )
        {
            bInArray = false;
        }
		else if ( c == sep )
		{
			if ( !bInArray && nParCount == 0 )
			{
				bFound = sal_True;
				nStart--;	// einen zu weit gelesen
			}
		}
		nStart++; // hinter gefundene Position stellen
	}

	return nStart;
}

//------------------------------------------------------------------

xub_StrLen FormulaHelper::GetArgStart( const String& rStr, xub_StrLen nStart, sal_uInt16 nArg ) const
{
	xub_StrLen nStrLen = rStr.Len();

	if ( nStrLen < nStart )
		return nStart;

	short	nParCount	= 0;
    bool    bInArray    = false;
	sal_Bool	bFound		= sal_False;

	while ( !bFound && (nStart < nStrLen) )
	{
		sal_Unicode c = rStr.GetChar(nStart);

		if ( c == '"' )
		{
			nStart++;
			while ( (nStart < nStrLen) && rStr.GetChar(nStart) != '"' )
				nStart++;
		}
		else if ( c == open )
		{
			bFound = ( nArg == 0 );
			nParCount++;
		}
		else if ( c == close )
		{
			nParCount--;
			bFound = ( nParCount == 0 );
		}
        else if ( c == arrayOpen )
        {
            bInArray = true;
        }
        else if ( c == arrayClose )
        {
            bInArray = false;
        }
		else if ( c == sep )
		{
			if ( !bInArray && nParCount == 1 )
			{
				nArg--;
				bFound = ( nArg == 0  );
			}
		}
		nStart++;
	}

	return nStart;
}
// =============================================================================
} // formula
// =============================================================================