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

#include <sal/types.h>

#include <o3tl/safeint.hxx>

#include <osl/diagnose.h>

#include <formula/funcvarargs.h>

#include <vcl/svapp.hxx>

#include <sfx2/app.hxx>

#include <sfx2/sfxmodelfactory.hxx>

#include <miscuno.hxx>

#include <scmod.hxx>

#include <appoptio.hxx>

#include <inputopt.hxx>

#include <printopt.hxx>

#include <userlist.hxx>

#include <scdll.hxx>

#include <unonames.hxx>

#include <funcdesc.hxx>

#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>

#include <com/sun/star/sheet/FunctionArgument.hpp>

#include <memory>

using namespace com::sun::star;

//  Special value for zoom

//! somewhere central

#define SC_ZOOMVAL_OPTIMAL      (-1)

#define SC_ZOOMVAL_WHOLEPAGE    (-2)

#define SC_ZOOMVAL_PAGEWIDTH    (-3)

//  Number of PropertyValues in a function description

#define SC_FUNCDESC_PROPCOUNT   5

//  everything without Which-ID, map only for PropertySetInfo

static std::span<const SfxItemPropertyMapEntry> lcl_GetSettingsPropertyMap()

{

    static const SfxItemPropertyMapEntry aSettingsPropertyMap_Impl[] =

    {

        { SC_UNONAME_DOAUTOCP, 0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_ENTERED,  0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_EXPREF,   0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_EXTFMT,   0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_LINKUPD,  0,  cppu::UnoType<sal_Int16>::get(),        0, 0},

        { SC_UNONAME_MARKHDR,  0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_METRIC,   0,  cppu::UnoType<sal_Int16>::get(),        0, 0},

        { SC_UNONAME_MOVEDIR,  0,  cppu::UnoType<sal_Int16>::get(),        0, 0},

        { SC_UNONAME_MOVESEL,  0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_PRALLSH,  0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_PREMPTY,  0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_RANGEFIN, 0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_SCALE,    0,  cppu::UnoType<sal_Int16>::get(),        0, 0},

        { SC_UNONAME_STBFUNC,  0,  cppu::UnoType<sal_Int16>::get(),        0, 0},

        { SC_UNONAME_ULISTS,   0,  cppu::UnoType<uno::Sequence<OUString>>::get(), 0, 0},

        { SC_UNONAME_PRMETRICS,0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_USETABCOL,0,  cppu::UnoType<bool>::get(),              0, 0},

        { SC_UNONAME_REPLWARN, 0,  cppu::UnoType<bool>::get(),              0, 0},

    };

    return aSettingsPropertyMap_Impl;

}

constexpr OUString SCFUNCTIONLISTOBJ_SERVICE = u"com.sun.star.sheet.FunctionDescriptions"_ustr;

constexpr OUString SCRECENTFUNCTIONSOBJ_SERVICE = u"com.sun.star.sheet.RecentFunctions"_ustr;

constexpr OUString SCSPREADSHEETSETTINGS_SERVICE = u"com.sun.star.sheet.GlobalSheetSettings"_ustr;

SC_SIMPLE_SERVICE_INFO( ScFunctionListObj, u"stardiv.StarCalc.ScFunctionListObj"_ustr, SCFUNCTIONLISTOBJ_SERVICE )

SC_SIMPLE_SERVICE_INFO( ScRecentFunctionsObj, u"stardiv.StarCalc.ScRecentFunctionsObj"_ustr, SCRECENTFUNCTIONSOBJ_SERVICE )

SC_SIMPLE_SERVICE_INFO( ScSpreadsheetSettings, u"stardiv.StarCalc.ScSpreadsheetSettings"_ustr, SCSPREADSHEETSETTINGS_SERVICE )

ScSpreadsheetSettings::ScSpreadsheetSettings() :

    aPropSet( lcl_GetSettingsPropertyMap() )

{

}

ScSpreadsheetSettings::~ScSpreadsheetSettings()

{

}

extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*

Calc_ScSpreadsheetSettings_get_implementation(

    css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)

{

    SolarMutexGuard aGuard;

    ScDLL::Init();

    return cppu::acquire(new ScSpreadsheetSettings());

}

bool ScSpreadsheetSettings::getPropertyBool(const OUString& aPropertyName)

{

   uno::Any any = getPropertyValue(aPropertyName);

   bool b = false;

   any >>= b;

   return b;

}

sal_Int16 ScSpreadsheetSettings::getPropertyInt16(const OUString& aPropertyName)

{

   uno::Any any = getPropertyValue(aPropertyName);

   sal_Int16 b = 0;

   any >>= b;

   return b;

}

// XPropertySet

uno::Reference<beans::XPropertySetInfo> SAL_CALL ScSpreadsheetSettings::getPropertySetInfo()

{

    SolarMutexGuard aGuard;

    static uno::Reference<beans::XPropertySetInfo> aRef(

        new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));

    return aRef;

}

void SAL_CALL ScSpreadsheetSettings::setPropertyValue(

                        const OUString& aPropertyName, const uno::Any& aValue )

{

    SolarMutexGuard aGuard;

    ScModule* pScMod = ScModule::get();

    ScAppOptions   aAppOpt(pScMod->GetAppOptions());

    ScInputOptions aInpOpt(pScMod->GetInputOptions());

    bool bSaveApp = false;

    bool bSaveInp = false;

    // print options aren't loaded until needed

    if (aPropertyName == SC_UNONAME_DOAUTOCP)

    {

        aAppOpt.SetAutoComplete( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveApp = true;

    }

    else if (aPropertyName == SC_UNONAME_ENTERED)

    {

        aInpOpt.SetEnterEdit( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_EXPREF)

    {

        aInpOpt.SetExpandRefs( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_EXTFMT)

    {

        aInpOpt.SetExtendFormat( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_LINKUPD)

    {

        // XXX NOTE: this is not css::document::Settings property

        // LinkUpdateMode but css::sheet::XGlobalSheetSettings attribute

        // LinkUpdateMode.

        sal_Int16 n;

        if (!(aValue >>= n) || n < 0 || n >= ScLkUpdMode::LM_UNKNOWN)

        {

            throw css::lang::IllegalArgumentException(

                (u"LinkUpdateMode property value must be a SHORT with a value in the range of 0--2"

                 " as documented for css::sheet::XGlobalSheetSettings attribute LinkUpdateMode"_ustr),

                css::uno::Reference<css::uno::XInterface>(), -1);

        }

        aAppOpt.SetLinkMode( static_cast<ScLkUpdMode>(n) );

        bSaveApp = true;

    }

    else if (aPropertyName == SC_UNONAME_MARKHDR)

    {

        aInpOpt.SetMarkHeader( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_MOVESEL)

    {

        aInpOpt.SetMoveSelection( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_RANGEFIN)

    {

        aInpOpt.SetRangeFinder( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_USETABCOL)

    {

        aInpOpt.SetUseTabCol( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_PRMETRICS)

    {

        aInpOpt.SetTextWysiwyg( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_REPLWARN)

    {

        aInpOpt.SetReplaceCellsWarn( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_METRIC)

    {

        aAppOpt.SetAppMetric( static_cast<FieldUnit>(ScUnoHelpFunctions::GetInt16FromAny( aValue )) );

        bSaveApp = true;

    }

    else if (aPropertyName == SC_UNONAME_MOVEDIR)

    {

        aInpOpt.SetMoveDir( ScUnoHelpFunctions::GetInt16FromAny( aValue ) );

        bSaveInp = true;

    }

    else if (aPropertyName == SC_UNONAME_SCALE)

    {

        short nVal = ScUnoHelpFunctions::GetInt16FromAny( aValue );

        if ( nVal < 0 )

        {

            SvxZoomType eType = SvxZoomType::PERCENT;

            switch (nVal)

            {

                case SC_ZOOMVAL_OPTIMAL:    eType = SvxZoomType::OPTIMAL;   break;

                case SC_ZOOMVAL_WHOLEPAGE:  eType = SvxZoomType::WHOLEPAGE; break;

                case SC_ZOOMVAL_PAGEWIDTH:  eType = SvxZoomType::PAGEWIDTH; break;

            }

            aAppOpt.SetZoomType( eType );

        }

        else if ( nVal >= MINZOOM && nVal <= MAXZOOM )

        {

            aAppOpt.SetZoom( nVal );

            aAppOpt.SetZoomType( SvxZoomType::PERCENT );

        }

        bSaveApp = true;

    }

    else if (aPropertyName == SC_UNONAME_STBFUNC)

    {

        aAppOpt.SetStatusFunc( ScUnoHelpFunctions::GetInt16FromAny( aValue ) );

        bSaveApp = true;

    }

    else if (aPropertyName == SC_UNONAME_ULISTS)

    {

        ScUserList& rUserList = ScGlobal::GetUserList();

        uno::Sequence<OUString> aSeq;

        if (aValue >>= aSeq)

        {

            //  directly change the active list

            //  ScGlobal::SetUseTabCol does not do much else

            rUserList.clear();

            for (const OUString& aEntry : aSeq)

            {

                rUserList.emplace_back(aEntry);

            }

            bSaveApp = true;    // List with App-Options are saved

        }

    }

    else if (aPropertyName == SC_UNONAME_PRALLSH)

    {

        ScPrintOptions aPrintOpt(pScMod->GetPrintOptions());

        aPrintOpt.SetAllSheets( ScUnoHelpFunctions::GetBoolFromAny( aValue ) );

        pScMod->SetPrintOptions( aPrintOpt );

    }

    else if (aPropertyName == SC_UNONAME_PREMPTY)

    {

        ScPrintOptions aPrintOpt(pScMod->GetPrintOptions());

        aPrintOpt.SetSkipEmpty( !ScUnoHelpFunctions::GetBoolFromAny( aValue ) );    // reversed

        pScMod->SetPrintOptions( aPrintOpt );

        SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScPrintOptions ) );    // update previews

    }

    if ( bSaveApp )

        pScMod->SetAppOptions( aAppOpt );

    if ( bSaveInp )

        pScMod->SetInputOptions( aInpOpt );

}

uno::Any SAL_CALL ScSpreadsheetSettings::getPropertyValue( const OUString& aPropertyName )

{

    SolarMutexGuard aGuard;

    uno::Any aRet;

    ScModule* pScMod = ScModule::get();

    ScAppOptions   aAppOpt = pScMod->GetAppOptions();

    const ScInputOptions& aInpOpt = pScMod->GetInputOptions();

    // print options aren't loaded until needed

    if (aPropertyName == SC_UNONAME_DOAUTOCP) aRet <<= aAppOpt.GetAutoComplete();

    else if (aPropertyName == SC_UNONAME_ENTERED ) aRet <<= aInpOpt.GetEnterEdit();

    else if (aPropertyName == SC_UNONAME_EXPREF ) aRet <<= aInpOpt.GetExpandRefs();

    else if (aPropertyName == SC_UNONAME_EXTFMT ) aRet <<= aInpOpt.GetExtendFormat();

    else if (aPropertyName == SC_UNONAME_LINKUPD ) aRet <<= static_cast<sal_Int16>(aAppOpt.GetLinkMode());

    else if (aPropertyName == SC_UNONAME_MARKHDR ) aRet <<= aInpOpt.GetMarkHeader();

    else if (aPropertyName == SC_UNONAME_MOVESEL ) aRet <<= aInpOpt.GetMoveSelection();

    else if (aPropertyName == SC_UNONAME_RANGEFIN ) aRet <<= aInpOpt.GetRangeFinder();

    else if (aPropertyName == SC_UNONAME_USETABCOL ) aRet <<= aInpOpt.GetUseTabCol();

    else if (aPropertyName == SC_UNONAME_PRMETRICS ) aRet <<= aInpOpt.GetTextWysiwyg();

    else if (aPropertyName == SC_UNONAME_REPLWARN ) aRet <<= aInpOpt.GetReplaceCellsWarn();

    else if (aPropertyName == SC_UNONAME_METRIC )  aRet <<= static_cast<sal_Int16>(aAppOpt.GetAppMetric());

    else if (aPropertyName == SC_UNONAME_MOVEDIR ) aRet <<= static_cast<sal_Int16>(aInpOpt.GetMoveDir());

    else if (aPropertyName == SC_UNONAME_STBFUNC ) aRet <<= static_cast<sal_Int16>(aAppOpt.GetStatusFunc());

    else if (aPropertyName == SC_UNONAME_SCALE )

    {

        sal_Int16 nZoomVal = 0;

        switch ( aAppOpt.GetZoomType() )

        {

            case SvxZoomType::PERCENT:   nZoomVal = aAppOpt.GetZoom();    break;

            case SvxZoomType::OPTIMAL:   nZoomVal = SC_ZOOMVAL_OPTIMAL;   break;

            case SvxZoomType::WHOLEPAGE: nZoomVal = SC_ZOOMVAL_WHOLEPAGE; break;

            case SvxZoomType::PAGEWIDTH: nZoomVal = SC_ZOOMVAL_PAGEWIDTH; break;

            default:

            {

                // added to avoid warnings

            }

        }

        aRet <<= nZoomVal;

    }

    else if (aPropertyName == SC_UNONAME_ULISTS )

    {

        const ScUserList& rUserList = ScGlobal::GetUserList();

        size_t nCount = rUserList.size();

        uno::Sequence<OUString> aSeq(nCount);

        OUString* pAry = aSeq.getArray();

        for (size_t i=0; i<nCount; ++i)

            pAry[i] = rUserList[i].GetString();

        aRet <<= aSeq;

    }

    else if (aPropertyName == SC_UNONAME_PRALLSH )

        aRet <<= pScMod->GetPrintOptions().GetAllSheets();

    else if (aPropertyName == SC_UNONAME_PREMPTY )

        aRet <<= !pScMod->GetPrintOptions().GetSkipEmpty();    // reversed

    return aRet;

}

SC_IMPL_DUMMY_PROPERTY_LISTENER( ScSpreadsheetSettings )

ScRecentFunctionsObj::ScRecentFunctionsObj()

{

}

ScRecentFunctionsObj::~ScRecentFunctionsObj()

{

}

extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*

ScRecentFunctionsObj_get_implementation(css::uno::XComponentContext*, css::uno::Sequence<css::uno::Any> const &)

{

    SolarMutexGuard aGuard;

    ScDLL::Init();

    return cppu::acquire(new ScRecentFunctionsObj());

}

// XRecentFunctions

uno::Sequence<sal_Int32> SAL_CALL ScRecentFunctionsObj::getRecentFunctionIds()

{

    SolarMutexGuard aGuard;

    const ScAppOptions& rOpt = ScModule::get()->GetAppOptions();

    sal_uInt16 nCount = rOpt.GetLRUFuncListCount();

    const sal_uInt16* pFuncs = rOpt.GetLRUFuncList();

    if (pFuncs)

    {

        uno::Sequence<sal_Int32> aSeq(nCount);

        sal_Int32* pAry = aSeq.getArray();

        for (sal_uInt16 i=0; i<nCount; i++)

            pAry[i] = pFuncs[i];

        return aSeq;

    }

    return {};

}

void SAL_CALL ScRecentFunctionsObj::setRecentFunctionIds(

                    const uno::Sequence<sal_Int32>& aRecentFunctionIds )

{

    SolarMutexGuard aGuard;

    sal_uInt16 nCount = static_cast<sal_uInt16>(std::min( aRecentFunctionIds.getLength(), sal_Int32(LRU_MAX) ));

    const sal_Int32* pAry = aRecentFunctionIds.getConstArray();

    std::unique_ptr<sal_uInt16[]> pFuncs(nCount ? new sal_uInt16[nCount] : nullptr);

    for (sal_uInt16 i=0; i<nCount; i++)

        pFuncs[i] = static_cast<sal_uInt16>(pAry[i]);        //! check for valid values?

    ScModule* pScMod = ScModule::get();

    ScAppOptions aNewOpts(pScMod->GetAppOptions());

    aNewOpts.SetLRUFuncList(pFuncs.get(), nCount);

    pScMod->SetAppOptions(aNewOpts);

}

sal_Int32 SAL_CALL ScRecentFunctionsObj::getMaxRecentFunctions()

{

    return LRU_MAX;

}

ScFunctionListObj::ScFunctionListObj()

{

}

ScFunctionListObj::~ScFunctionListObj()

{

}

extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*

ScFunctionListObj_get_implementation(css::uno::XComponentContext*, css::uno::Sequence<css::uno::Any> const &)

{

    SolarMutexGuard aGuard;

    ScDLL::Init();

    return cppu::acquire(new ScFunctionListObj());

}

static void lcl_FillSequence( uno::Sequence<beans::PropertyValue>& rSequence, const ScFuncDesc& rDesc )

{

    rDesc.initArgumentInfo();   // full argument info is needed

    OSL_ENSURE( rSequence.getLength() == SC_FUNCDESC_PROPCOUNT, "Wrong count" );

    beans::PropertyValue* pArray = rSequence.getArray();

    pArray[0].Name = SC_UNONAME_ID;

    pArray[0].Value <<= static_cast<sal_Int32>(rDesc.nFIndex);

    pArray[1].Name = SC_UNONAME_CATEGORY;

    pArray[1].Value <<= static_cast<sal_Int32>(rDesc.nCategory);

    pArray[2].Name = SC_UNONAME_NAME;

    if (rDesc.mxFuncName)

        pArray[2].Value <<= *rDesc.mxFuncName;

    pArray[3].Name = SC_UNONAME_DESCRIPTION;

    if (rDesc.mxFuncDesc)

        pArray[3].Value <<= *rDesc.mxFuncDesc;

    pArray[4].Name = SC_UNONAME_ARGUMENTS;

    if (rDesc.maDefArgNames.empty() || rDesc.maDefArgDescs.empty() || !rDesc.pDefArgFlags)

        return;

    sal_uInt16 nCount = rDesc.nArgCount;

    if (nCount >= PAIRED_VAR_ARGS)

        nCount -= PAIRED_VAR_ARGS - 2;

    else if (nCount >= VAR_ARGS)

        nCount -= VAR_ARGS - 1;

    sal_uInt16 nSeqCount = rDesc.GetSuppressedArgCount();

    if (nSeqCount >= PAIRED_VAR_ARGS)

        nSeqCount -= PAIRED_VAR_ARGS - 2;

    else if (nSeqCount >= VAR_ARGS)

        nSeqCount -= VAR_ARGS - 1;

    if (!nSeqCount)

        return;

    uno::Sequence<sheet::FunctionArgument> aArgSeq(nSeqCount);

    sheet::FunctionArgument* pArgAry = aArgSeq.getArray();

    for (sal_uInt16 i=0, j=0; i<nCount; i++)

    {

        sheet::FunctionArgument aArgument;

        aArgument.Name        = rDesc.maDefArgNames[i];

        aArgument.Description = rDesc.maDefArgDescs[i];

        aArgument.IsOptional  = rDesc.pDefArgFlags[i].bOptional;

        pArgAry[j++] = std::move(aArgument);

    }

    pArray[4].Value <<= aArgSeq;

}

// XFunctionDescriptions

uno::Sequence<beans::PropertyValue> SAL_CALL ScFunctionListObj::getById( sal_Int32 nId )

{

    SolarMutexGuard aGuard;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( !pFuncList )

        throw uno::RuntimeException();                  // should not happen

    sal_uInt16 nCount = static_cast<sal_uInt16>(pFuncList->GetCount());

    for (sal_uInt16 nIndex=0; nIndex<nCount; nIndex++)

    {

        const ScFuncDesc* pDesc = pFuncList->GetFunction(nIndex);

        if ( pDesc && pDesc->nFIndex == nId )

        {

            uno::Sequence<beans::PropertyValue> aSeq( SC_FUNCDESC_PROPCOUNT );

            lcl_FillSequence( aSeq, *pDesc );

            return aSeq;

        }

    }

    throw lang::IllegalArgumentException();         // not found

}

// XNameAccess

uno::Any SAL_CALL ScFunctionListObj::getByName( const OUString& aName )

{

    SolarMutexGuard aGuard;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( !pFuncList )

        throw uno::RuntimeException();                  // should not happen

    sal_uInt16 nCount = static_cast<sal_uInt16>(pFuncList->GetCount());

    for (sal_uInt16 nIndex=0; nIndex<nCount; nIndex++)

    {

        const ScFuncDesc* pDesc = pFuncList->GetFunction(nIndex);

        //! Case-insensitive???

        if ( pDesc && pDesc->mxFuncName && aName == *pDesc->mxFuncName )

        {

            uno::Sequence<beans::PropertyValue> aSeq( SC_FUNCDESC_PROPCOUNT );

            lcl_FillSequence( aSeq, *pDesc );

            return uno::Any(aSeq);

        }

    }

    throw container::NoSuchElementException();      // not found

}

// XIndexAccess

sal_Int32 SAL_CALL ScFunctionListObj::getCount()

{

    SolarMutexGuard aGuard;

    sal_Int32 nCount = 0;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( pFuncList )

        nCount = static_cast<sal_Int32>(pFuncList->GetCount());

    return nCount;

}

uno::Any SAL_CALL ScFunctionListObj::getByIndex( sal_Int32 nIndex )

{

    SolarMutexGuard aGuard;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( !pFuncList )

        throw uno::RuntimeException();                  // should not happen

    if ( nIndex >= 0 && o3tl::make_unsigned(nIndex) < pFuncList->GetCount() )

    {

        const ScFuncDesc* pDesc = pFuncList->GetFunction(nIndex);

        if ( pDesc )

        {

            uno::Sequence<beans::PropertyValue> aSeq( SC_FUNCDESC_PROPCOUNT );

            lcl_FillSequence( aSeq, *pDesc );

            return uno::Any(aSeq);

        }

    }

    throw lang::IndexOutOfBoundsException();        // illegal index

}

// XEnumerationAccess

uno::Reference<container::XEnumeration> SAL_CALL ScFunctionListObj::createEnumeration()

{

    SolarMutexGuard aGuard;

    return new ScIndexEnumeration(this, u"com.sun.star.sheet.FunctionDescriptionEnumeration"_ustr);

}

// XElementAccess

uno::Type SAL_CALL ScFunctionListObj::getElementType()

{

    return cppu::UnoType<uno::Sequence<beans::PropertyValue>>::get();

}

sal_Bool SAL_CALL ScFunctionListObj::hasElements()

{

    SolarMutexGuard aGuard;

    return ( getCount() > 0 );

}

uno::Sequence<OUString> SAL_CALL ScFunctionListObj::getElementNames()

{

    SolarMutexGuard aGuard;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( pFuncList )

    {

        sal_uInt32 nCount = pFuncList->GetCount();

        uno::Sequence<OUString> aSeq(nCount);

        OUString* pAry = aSeq.getArray();

        for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)

        {

            const ScFuncDesc* pDesc = pFuncList->GetFunction(nIndex);

            if ( pDesc && pDesc->mxFuncName )

                pAry[nIndex] = *pDesc->mxFuncName;

        }

        return aSeq;

    }

    return {};

}

sal_Bool SAL_CALL ScFunctionListObj::hasByName( const OUString& aName )

{

    SolarMutexGuard aGuard;

    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();

    if ( pFuncList )

    {

        sal_uInt32 nCount = pFuncList->GetCount();

        for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)

        {

            const ScFuncDesc* pDesc = pFuncList->GetFunction(nIndex);

            //! Case-insensitive???

            if ( pDesc && pDesc->mxFuncName && aName == *pDesc->mxFuncName )

                return true;

        }

    }

    return false;

}

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