/**************************************************************
 * 
 * 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_extensions.hxx"
#include "res_services.hxx"

#include <vos/mutex.hxx>
#include <uno/lbnames.h>			// CPPU_CURRENT_LANGUAGE_BINDING_NAME macro, which specify the environment type
#include <cppuhelper/factory.hxx>	// helper for factories
#include <cppuhelper/implbase3.hxx>	// helper for implementations

#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/script/XInvocation.hpp>
#include <com/sun/star/script/XTypeConverter.hpp>
#include <com/sun/star/reflection/InvocationTargetException.hpp>
#include <com/sun/star/beans/XExactName.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/beans/PropertyState.hpp>

#include <tools/resmgr.hxx>
#include <tools/rcid.h>
#include <tools/resary.hxx>
#include <vcl/svapp.hxx>

#include <rtl/ustring.hxx>
#include <rtl/strbuf.hxx>

using namespace vos;
using namespace rtl;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::registry;
using namespace com::sun::star::script;
using namespace com::sun::star::beans;
using namespace com::sun::star::reflection;

//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
class ResourceService : public cppu::WeakImplHelper3< XInvocation, XExactName, XServiceInfo >
{
public:
								ResourceService( const Reference< XMultiServiceFactory > & );
								~ResourceService();

	// XServiceInfo
	OUString SAL_CALL			getImplementationName() throw();
    sal_Bool 	 SAL_CALL			supportsService(const OUString& ServiceName) throw();
    Sequence< OUString > SAL_CALL	getSupportedServiceNames(void) throw();

    static Sequence< OUString > getSupportedServiceNames_Static(void) throw();
	static OUString 			getImplementationName_Static() throw()
								{
									return OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.extensions.ResourceService"));
								}
    static Reference< XInterface > Create( const Reference< XComponentContext >& _rxContext );

	// XExactName
	OUString  SAL_CALL			getExactName( const OUString & ApproximateName ) throw(RuntimeException);

	// XInvokation
    Reference< XIntrospectionAccess >  SAL_CALL getIntrospection(void)  throw(RuntimeException);
    Any  SAL_CALL				invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam) throw(IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException);
    void  SAL_CALL				setValue(const OUString& PropertyName, const Any& Value) throw(UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException);
    Any  SAL_CALL				getValue(const OUString& PropertyName) throw(UnknownPropertyException, RuntimeException);
    sal_Bool  SAL_CALL				hasMethod(const OUString& Name)  throw(RuntimeException);
    sal_Bool  SAL_CALL				hasProperty(const OUString& Name)  throw(RuntimeException);
private:
	Reference< XTypeConverter >			getTypeConverter() const;
	Reference< XInvocation >			getDefaultInvocation() const;

	Reference< XMultiServiceFactory >	xSMgr;
	Reference< XInvocation >			xDefaultInvocation;
	Reference< XTypeConverter >			xTypeConverter;
	OUString								aFileName;
	ResMgr *							pResMgr;
};


//-----------------------------------------------------------------------------
ResourceService::ResourceService( const Reference< XMultiServiceFactory > & rSMgr )
	: xSMgr( rSMgr )
	, pResMgr( NULL )
{
}

//-----------------------------------------------------------------------------
Reference< XInterface > ResourceService::Create( const Reference< XComponentContext >& _rxContext )
{
    Reference< XMultiServiceFactory > xFactory( _rxContext->getServiceManager(), UNO_QUERY_THROW );
    return *( new ResourceService( xFactory ) );
}

//-----------------------------------------------------------------------------
ResourceService::~ResourceService()
{
	delete pResMgr;
}

// XServiceInfo
OUString ResourceService::getImplementationName() throw()
{
	return getImplementationName_Static();
}

// XServiceInfo
sal_Bool SAL_CALL ResourceService::supportsService(const OUString& ServiceName) throw()
{
	Sequence< OUString > aSNL = getSupportedServiceNames();
	const OUString * pArray = aSNL.getConstArray();
	for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
		if( pArray[i] == ServiceName )
			return sal_True;
	return sal_False;
}

// XServiceInfo
Sequence< OUString > SAL_CALL ResourceService::getSupportedServiceNames(void) throw()
{
	return getSupportedServiceNames_Static();
}

// ResourceService
Sequence< OUString > ResourceService::getSupportedServiceNames_Static(void) throw()
{
	Sequence< OUString > aSNS( 1 );
	aSNS.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.resource.VclStringResourceLoader"));
	return aSNS;
}

// ResourceService
Reference< XTypeConverter > ResourceService::getTypeConverter() const
{
	OGuard aGuard( Application::GetSolarMutex() );
	if( xSMgr.is() )
	{
		Reference< XTypeConverter > xConv( xSMgr->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter" ))), UNO_QUERY );
		((ResourceService*)this)->xTypeConverter = xConv;
	}
	return xTypeConverter;
}

// ResourceService
Reference< XInvocation > ResourceService::getDefaultInvocation() const
{
	OGuard aGuard( Application::GetSolarMutex() );
	/* f�hrt zur Zeit noch zu einer rekursion
	if( xSMgr.is() )
	{
		Reference< XSingleServiceFactory > xFact( xSMgr->createInstance( OUString::createFromAscii("com.sun.star.script.Invocation") ), UNO_QUERY );
		if( xFact.is() )
		{
			Sequence< Any > aArgs( 1 );
			Reference< XInterface > xThis( *this );
			aArgs.getArray()[0].set( &xThis, XInterface_Reference< get >lection() );
			Reference< XInvokation > xI( xFact->createInstanceWithArguments( aArgs ), UNO_QUERY );
			((ResourceService*)this)->xDefaultInvocation = xI;
		}
	}
	*/
	return xDefaultInvocation;
}

// XExactName
OUString	SAL_CALL ResourceService::getExactName( const OUString & ApproximateName ) throw(RuntimeException)
{
	OUString aName( ApproximateName );
	aName = aName.toAsciiLowerCase();
	if( aName.equalsAscii("filename") )
		return OUString(RTL_CONSTASCII_USTRINGPARAM("FileName"));
	else if( aName.equalsAscii("getstring" ))
		return OUString(RTL_CONSTASCII_USTRINGPARAM("getString"));
	else if( aName.equalsAscii("getstrings" ))
		return OUString(RTL_CONSTASCII_USTRINGPARAM("getStrings"));
	else if( aName.equalsAscii("hasstring") )
		return OUString(RTL_CONSTASCII_USTRINGPARAM("hasString"));
	else if( aName.equalsAscii("hasstrings") )
		return OUString(RTL_CONSTASCII_USTRINGPARAM("hasStrings"));
	else if( aName.equalsAscii("getstringlist") )
		return OUString(RTL_CONSTASCII_USTRINGPARAM("getStringList"));
	else if( aName.equalsAscii("hasStringList") )
		return OUString(RTL_CONSTASCII_USTRINGPARAM("hasStringList"));
	Reference< XExactName > xEN( getDefaultInvocation(), UNO_QUERY );
	if( xEN.is() )
		return xEN->getExactName( ApproximateName );
	return OUString();
}

// XInvokation
Reference< XIntrospectionAccess > SAL_CALL ResourceService::getIntrospection(void)  
	throw(RuntimeException)
{
	Reference< XInvocation > xI = getDefaultInvocation();
	if( xI.is() )
		return xI->getIntrospection();
	return Reference< XIntrospectionAccess >();
}

// XInvokation
Any SAL_CALL ResourceService::invoke
(
	const OUString& FunctionName, 
	const Sequence< Any >& Params, 
	Sequence< sal_Int16 >& OutParamIndex, 
	Sequence< Any >& OutParam
)
	throw(IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException)
{
    Any aRet;
	if( FunctionName.equalsAscii("getString")
        || FunctionName.equalsAscii("getStrings" )
        || FunctionName.equalsAscii("hasString" )
        || FunctionName.equalsAscii("hasStrings" )
        )
	{
        sal_Int32 nElements = Params.getLength();
        if( nElements < 1 )
            throw IllegalArgumentException();
        if( nElements > 1 && (FunctionName.equalsAscii("getString") || FunctionName.equalsAscii("hasString") ) )
            throw IllegalArgumentException();
        if( !pResMgr )
            throw IllegalArgumentException();
        
        Sequence< OUString > aStrings( Params.getLength() );
        Sequence< sal_Bool > aBools( Params.getLength() );
        const Any* pIn = Params.getConstArray();
        OUString* pOutString = aStrings.getArray();
        sal_Bool* pOutBool = aBools.getArray();
        
        Reference< XTypeConverter > xC = getTypeConverter();
        bool bGetBranch = FunctionName.equalsAscii( "getString" ) || FunctionName.equalsAscii( "getStrings" );
            
        OGuard aGuard( Application::GetSolarMutex() );
        for( sal_Int32 n = 0; n < nElements; n++ )
        {
            sal_Int32 nId = 0;
            if( !(pIn[n] >>= nId) )
            {
                if( xC.is() )
                {
                    xC->convertToSimpleType( pIn[n], TypeClass_LONG ) >>= nId;
                }
                else
                    throw CannotConvertException();
            }
            if( nId > 0xFFFF || nId < 0 )
                throw IllegalArgumentException();
            
            if( bGetBranch )
            {
                ResId aId( (sal_uInt16)nId, *pResMgr );
                aId.SetRT( RSC_STRING );
                if( pResMgr->IsAvailable( aId ) )
                {
                    String aStr( aId );
                    pOutString[n] = aStr;
                }
                else
                    throw IllegalArgumentException();
            }
            else // hasString(s)
            {
                sal_Bool bRet = sal_False;
                if( pResMgr )
                {
                    ResId aId( (sal_uInt16)nId, *pResMgr );
                    aId.SetRT( RSC_STRING );
                    bRet = pResMgr->IsAvailable( aId );
                }
                pOutBool[n] = bRet;
            }
        }
        if( FunctionName.equalsAscii("getString") )
            aRet <<= pOutString[0];
        else if( FunctionName.equalsAscii("getStrings" ) )
            aRet <<= aStrings;
        else if( FunctionName.equalsAscii("hasString" ) )
            aRet <<= pOutBool[0];
        else
            aRet <<= aBools;
    }
    else if( FunctionName.equalsAscii("getStringList") || FunctionName.equalsAscii("hasStringList" ) )
    {
        if( Params.getLength() != 1 )
            throw IllegalArgumentException();
        Reference< XTypeConverter > xC = getTypeConverter();
        OGuard aGuard( Application::GetSolarMutex() );

        sal_Int32 nId = 0;
        if( !(Params.getConstArray()[0] >>= nId) )
        {
            if( xC.is() )
            {
                xC->convertToSimpleType( Params.getConstArray()[0], TypeClass_LONG ) >>= nId;
            }
            else
                throw CannotConvertException();
        }
        
        if( FunctionName.equalsAscii("getStringList") )
        {
            ResId aId( (sal_uInt16)nId, *pResMgr );
            aId.SetRT( RSC_STRINGARRAY );
            if( pResMgr->IsAvailable( aId ) )
            {
                ResStringArray aStr( aId );
                int nEntries = aStr.Count();
                Sequence< PropertyValue > aPropSeq( nEntries );
                PropertyValue* pOut = aPropSeq.getArray();
                for( int i = 0; i < nEntries; i++ )
                {
                    pOut[i].Name        = aStr.GetString( i );
                    pOut[i].Handle      = -1;
                    pOut[i].Value     <<= aStr.GetValue( i );
                    pOut[i].State       = PropertyState_DIRECT_VALUE;
                }
                aRet <<= aPropSeq;
            }
            else
                throw IllegalArgumentException();
        }
        else // hasStringList
        {
            sal_Bool bRet = sal_False;
            if( pResMgr )
            {
                ResId aId( (sal_uInt16)nId, *pResMgr );
                aId.SetRT( RSC_STRINGARRAY );
                bRet = pResMgr->IsAvailable( aId );
            }
            aRet <<= bRet;
        }
    }
	else
	{
		Reference< XInvocation > xI = getDefaultInvocation();
		if( xI.is() )
			return xI->invoke( FunctionName, Params, OutParamIndex, OutParam );
		else
			throw IllegalArgumentException();
	}
	return aRet;
}

// XInvokation
void SAL_CALL ResourceService::setValue(const OUString& PropertyName, const Any& Value) 
	throw(UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException)
{
	if( PropertyName.equalsAscii("FileName") )
	{
		OUString aName;
		if( !(Value >>= aName) )
		{
			Reference< XTypeConverter > xC = getTypeConverter();
			if( xC.is() )
				xC->convertToSimpleType( Value, TypeClass_STRING ) >>= aName;
			else
				throw CannotConvertException();
		}

		OGuard aGuard( Application::GetSolarMutex() );
        OStringBuffer aBuf( aName.getLength()+8 );
        aBuf.append( OUStringToOString( aName, osl_getThreadTextEncoding() ) );
		ResMgr * pRM = ResMgr::CreateResMgr( aBuf.getStr() );
		if( !pRM )
			throw InvocationTargetException();
		if( pResMgr )
			delete pResMgr;
		pResMgr = pRM;
		aFileName = OStringToOUString( aBuf.makeStringAndClear(), osl_getThreadTextEncoding() );
	}
	else
	{
		Reference< XInvocation > xI = getDefaultInvocation();
		if( xI.is() )
			xI->setValue( PropertyName, Value );
		else
			throw UnknownPropertyException();
	}
}

// XInvokation
Any SAL_CALL ResourceService::getValue(const OUString& PropertyName) 
	throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	if( PropertyName.equalsAscii("FileName" ))
		return makeAny( aFileName );

	Reference< XInvocation > xI = getDefaultInvocation();
	if( xI.is() )
		return xI->getValue( PropertyName );

	throw UnknownPropertyException();
}

// XInvokation
sal_Bool SAL_CALL ResourceService::hasMethod(const OUString& Name)  
	throw(RuntimeException)
{
	if( Name.equalsAscii("getString")     ||
        Name.equalsAscii("getStrings")    ||
        Name.equalsAscii("hasString")     ||
        Name.equalsAscii("hasStrings")    ||
        Name.equalsAscii("getStringList") ||
        Name.equalsAscii("hasStringList")
        )
		return sal_True;
	else
	{
		Reference< XInvocation > xI = getDefaultInvocation();
		if( xI.is() )
			return xI->hasMethod( Name );
		else
			return sal_False;
	}
}

// XInvokation
sal_Bool SAL_CALL ResourceService::hasProperty(const OUString& Name)  
	throw(RuntimeException)
{
	if( Name.equalsAscii("FileName") )
		return sal_True;
	else
	{
		Reference< XInvocation > xI = getDefaultInvocation();
		if( xI.is() )
			return xI->hasProperty( Name );
		else
			return sal_False;
	}
}

namespace res
{
    ComponentInfo getComponentInfo_VclStringResourceLoader()
    {
        ComponentInfo aInfo;
        aInfo.aSupportedServices = ResourceService::getSupportedServiceNames_Static();
        aInfo.sImplementationName = ResourceService::getImplementationName_Static();
        aInfo.pFactory = &ResourceService::Create;
        return aInfo;
    }
}