/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/


#ifndef PUSHSERVERCONNPLUGINMANAGER_H
#define PUSHSERVERCONNPLUGINMANAGER_H

#include <memory>
#include <list>
#include <map>
#include <string>
#include <exception>

#include "dynamiclibloader.h"
#include "scopedlocks.h"
#include "serverconnectionfactory.h"
#include "serverconnection.h"
#include "connectionlistener.h"
#include "pushregdata.h"


namespace java
{
namespace push
{

class PushControllerErrorHandlerInterface
{
public:

    virtual ~PushControllerErrorHandlerInterface() {}

    /**
     * This operation sends IPC_PR_ALL_CONNS_FAILED msg
     * to PushRegistryPlugin.
     * @throws This operation does not throw exceptions.
     */
    virtual void sendAllConnsFailedMsg() = 0;

    /**
     * This operation informs Runtime to close itself.
     * @throws This operation does not throw exceptions.
     */
    virtual void closeRuntime() = 0;

};

class ConnManagedInterface
{
public:

    virtual ~ConnManagedInterface() {}

    /**
     * This method sends IPC_PR_CONN_COMPLETED comms message to PushRegistryPlugin
     * when push connection, registered/unregistered by other MIDlet, has been completed.
     * @param aUri URI of the managed connection.
     */
    virtual void connCompleted(const std::wstring& aUri) = 0;

};

/**
 * This class contains Server Connection Plugin data. Reserved only for internal usage.
 */
class ServerConnectionPluginData
{
public:

    /**
     * @param aSrvConnLibAccess This class does not take ownership of this object.
     */
    ServerConnectionPluginData(java::util::DynamicLibLoader* aSrvConnLibAccess,
                               java::push::ServerConnectionFactory& aServerConnFactory)
            : mSrvConnLibAccess(aSrvConnLibAccess),mServerConnFactory(aServerConnFactory)
    {
    }

    virtual ~ServerConnectionPluginData()
    {
    }

    ServerConnectionPluginData(const ServerConnectionPluginData& x)
            : mSrvConnLibAccess(x.mSrvConnLibAccess),mServerConnFactory(x.mServerConnFactory)
    {
    }

    java::util::DynamicLibLoader* mSrvConnLibAccess;
    java::push::ServerConnectionFactory& mServerConnFactory;

private:
    //Not implemented.
    ServerConnectionPluginData &operator=(const ServerConnectionPluginData&);
};

/**
 * This class caches Server Connection Plugins. This class provides functionality to start
 * listening push connections, register and unregister new dynamic push registrations and
 * getting information from Server Connections.
 */
class PushServerConnPluginManager
{
public:

    typedef std::list<PushRegData> UriList_t;
    typedef std::list<PushRegData>::iterator UriListIter_t;

    /**
     * @param aListener This class does not take ownership into this argument.
     * @param aPendingConnListener This class does not take ownership into this argument.
     */
    PushServerConnPluginManager(ConnectionListener* aListener,
                                PendingConnectionListener* aPendingConnListener,
                                ConnManagedInterface* aConnManagedInterface);

    virtual ~PushServerConnPluginManager();

    /**
     * This operation is used to open push connections to listen arriving messages.
     * This operation loads Server Connection Plugins, creates ServerConnection objects and
     * calls ServerConnection.open() operation for each URI.
     * @param aUriList Push connection URIs.
     * @param aThrowException indicates whether this operation throws an exception
     *                        if creation/opening a connection fails.
     * @throws  PushException with following error codes:
     *          INVALID_URI:
     *          Uri passed as argument is not valid.
     *          COMMON_SRV_CONN_PLUGIN_ERROR:
     *          creation of ServerConnection object failed.
     *          INIT_OF_ALL_PUSH_CONNS_FAILED:
                initialization of all operations fails
     *          LibraryLoaderException with following error codes:
     *          OPENING_LIBRARY_FAILED:
     *          if opening a Server Connection Plugin failed.
     *          E.g. in the situation where certain protocol is not supported.
     *          CANNOT_FIND_FUNCTION_FAILURE:
     *          if function function by "getServerConnectionFactory" name is not found
     *          from ServerConnection Plugin.
     */
    void startListen(UriList_t& aUriList,bool aThrowException,bool aCallConnectionHandled);

    /**
     * This operation is used to update push connnections. This operation creates and
     * opens new push connections or closes and deletes/sets to "non-push" existing push connections.
     * @param aUriList Push connection URIs.
     * @param aErrorHandler error handler object.
     * @throws If error occurs in the update this operation send same exceptions as
     *         startListen(UriList_t& aUriList) operation.
     *         In the unregistering case this operation does not throw exceptions.
     */
    void updatePushRegs(UriList_t& aUriList,PushControllerErrorHandlerInterface& aErrorHandler);

    /**
     * This operation populates aUriList output argument with active or all push
     * connection URIs of the MIDlet depending value of the aAvailable argument.
     * @param aAvailable 'true' means that only active push connections are returned.
     *                   Active push connection means connection where msg has been arrived.
     *                   'false' means that all push connections of the MIDlet is returned.
     * @param aUriList Output argument. Push connection URIs are populated into this list.
     * @throws This operation does not throw exceptions.
     */
    void listConnections(bool aAvailable,std::list<std::wstring>& aUriList);

    /**
     * This operation returns push ServerConnection object.
     * @throws PushException with following error codes:
     *         SRV_CONN_NOT_FOUND:
     *         ServerConnectionFactory object by URI is not found or if ServerConnection
     *         by URI is not found.
     *         INVALID_URI:
     *         Scheme cannot be resolved from the URI.
     */
    ServerConnection& getPushConnection(const std::wstring& aUri);

    /**
     * Changed dynamic push registration to normal ServerConnection in the Server Connection Plugin.
     * This operation does not do anything if ServerConnection by URI is not found.
     * @throws  PushException with following error codes:
     *          INVALID_URI:
     *          Scheme cannot be resolved from the URI.
     */
    void unregisterDynamicPushConn(const std::wstring& aUri);

    /**
     * Push ServerConnection can be set to failed by this operation in the case where
     * ServerConnection calls error() operation.
     * @param aUri   Push connection URI.
     * @return int  Returns number of successful push ServerConnections.
     */
    int setConnFailed(const std::wstring& aUri);

    /**
     * Deletes ServerConnection from the ServerConnectionFactory.
     * This can be used e.g. in the error situation to remove already created
     * ServerConnection objects.
     * @param aUri   Push connection URI.
     * @throws This operation does not thrown exception.
     */
    void deletePushServerConn(const std::wstring& aUri);

    /**
     * This operation checks that connection is not accepted by an another
     * application. This operation must be called when push connection is registered
     * dynamically to other MIDlet in the suite.
     * @param aUri   Push connection URI.
     * @return true if URI is valid and push connection can be registered.
     * @throws This operation does not throw exceptions.
     */
    bool isValidPushUri(const std::wstring& aUri);

private:

    //Datamembers.
    typedef std::map<std::wstring,ServerConnectionPluginData> SrvConnContainer_t;
    typedef std::map<std::wstring,ServerConnectionPluginData>::iterator SrvConnContainerIter_t;
    SrvConnContainer_t mSrvConnContainer;

    typedef std::map<std::wstring,bool> SuccessPushConnList_t;
    typedef std::map<std::wstring,bool>::iterator SuccessPushConnListIter_t;
    SuccessPushConnList_t mSuccessPushConnList;

    //This class does not take ownershhip of the object.
    ConnectionListener* mConnListener;
    java::util::ScopedMutex mMutex;
    //This class does not take ownershhip of the object.
    PendingConnectionListener* mPendingConnListener;
    //This class does not take ownershhip of the object.
    ConnManagedInterface* mConnManagedInterface;

    //Internal operations.
    ServerConnectionFactory* getDllFromContainer(const std::wstring& aScheme);
    ServerConnectionFactory& loadAndStoreDll(const std::wstring& aUri,
            std::wstring& aOutScheme);
    void createAndOpenConn(const PushRegData& aData,const std::wstring& aScheme);
    std::wstring resolveScheme(const std::wstring& aUri) const;
    std::string resolveDllName(const std::wstring& aScheme) const;
    int getNumOfSuccessfulPushConns();
    void findAndDeleteUnregPushConns(std::list<std::wstring>& aExistingUriList,
                                     UriList_t& aNewUriListFromStorage,
                                     PushControllerErrorHandlerInterface& aErrorHandler);
    void findAndAddNewPushConns(std::list<std::wstring>& aExistingUriList,
                                UriList_t& aNewUriListFromStorage);

    //Not implemented.
    PushServerConnPluginManager(const PushServerConnPluginManager &x);
    PushServerConnPluginManager &operator=(const PushServerConnPluginManager &x);

};

}//end namespace push
}//end namespace java

#endif // PUSHSERVERCONNPLUGINMANAGER_H