/*
* Copyright (c) 2009 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:
*
*/

#include <memory>
#include <iostream>
#include <sstream>

#include "logger.h"

#include "serverconnectionfactorybase.h"
#include "runtimeexception.h"
#include "javacommonutils.h"
#include "pusherrorcodes.h"
#include "pushexception.h"
#include "pendingconnectionlistener.h"

using namespace java::push;
using namespace java::runtime;
using namespace java::util;

/**
 *
 */
OS_EXPORT ServerConnectionFactoryBase::ServerConnectionFactoryBase()
{
}

/**
 *
 */
OS_EXPORT ServerConnectionFactoryBase::~ServerConnectionFactoryBase()
{
    JELOG2(EJavaPush);
    try
    {
        for (SrvConnContainerIter_t iter = mServerConnections.begin();
                iter != mServerConnections.end(); ++iter)
        {
            delete(iter->second.getConn());
        }
        mServerConnections.clear();
    }
    catch (...)
    {
        ELOG(EJavaPush,"ERROR!!! ~ServerConnectionFactoryBase(): Unexpected exception was caught");
    }
}

/**
 *
 */
OS_EXPORT ServerConnection&
ServerConnectionFactoryBase::createPushServerConn(const std::wstring& aUri,
        const std::wstring& aFilter,
        ConnectionListener* aListener,
        PendingConnectionListener* aPendingConnListener)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter != mServerConnections.end())
    {
        if ((SrvConnContainerData::PUSH == iter->second.connType())
                || (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()))
        {
            std::string errTxt("Object already exists");
            ELOG1(EJavaPush, "ERROR: %s",errTxt.c_str());
            ELOG1WSTR(EJavaPush,"Error in createPushServerConn() URI: %s",aUri);
            throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,errTxt,__FILE__,__FUNCTION__,__LINE__);
        }
        else
        {
            //Connection type is NORMAL so we have to change it to PUSH_LISTEN_BY_MIDLET.
            iter->second.setConnType(SrvConnContainerData::PUSH_LISTEN_BY_MIDLET);
            iter->second.setPendingConnListener(aPendingConnListener);
            iter->second.getConn()->setFilter(aFilter);
            return *(iter->second.getConn());
        }
    }
    std::auto_ptr<ServerConnection> newSrvConn(createSrvConnObj(aUri,aFilter));
    newSrvConn->open(aListener);
    SrvConnContainerData newDataObj(newSrvConn.release(),aPendingConnListener,
                                    false,SrvConnContainerData::PUSH);
    mServerConnections.insert(std::pair<std::wstring,SrvConnContainerData>(aUri,newDataObj));

    return *(newDataObj.getConn());
}

/**
 *
 */
OS_EXPORT ServerConnection* ServerConnectionFactoryBase::create(const std::wstring& aUri)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter == mServerConnections.end())
    {
        std::auto_ptr<ServerConnection> newSrvConn(createSrvConnObj(aUri,L""));
        SrvConnContainerData newDataObj(newSrvConn.release(),0,false,SrvConnContainerData::NORMAL);
        mServerConnections.insert(std::pair<std::wstring,SrvConnContainerData>(aUri,newDataObj));
        return newDataObj.getConn();
    }

    if (!isMultipleSrvConnAllowed())
    {
        if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()
                || SrvConnContainerData::NORMAL == iter->second.connType())
        {
            std::string errTxt("Type of the connection is: ");
            errTxt.append(java::util::JavaCommonUtils::intToString((int)iter->second.connType()));
            throw PushException(PUSH_CONNECTION_ALREADY_EXISTS,errTxt,__FILE__,__FUNCTION__,__LINE__);
        }
    }

    if (SrvConnContainerData::PUSH == iter->second.connType())
    {
        iter->second.setConnType(SrvConnContainerData::PUSH_LISTEN_BY_MIDLET);
    }

    return (*iter).second.getConn();
}

/**
 *
 */
OS_EXPORT void
ServerConnectionFactoryBase::getPushConnections(bool aAvailable,std::list<std::wstring>& aUriList)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    for (SrvConnContainerIter_t iter = mServerConnections.begin(); iter != mServerConnections.end(); ++iter)
    {
        if ((SrvConnContainerData::PUSH == iter->second.connType())
                || (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType()))
        {
            if (true == aAvailable)
            {
                if (true == iter->second.isActive())
                {
                    aUriList.push_back((iter->first));
                }
            }
            else
            {
                WLOG1WSTR(EJavaPush,"ServerConnectionFactoryBase::getPushConnections() URI: %s",(iter->first));
                aUriList.push_back((iter->first));
            }
        }//end if( (SrvConnContainerData::PUSH == iter->second.connType())...)
    }//end for
}

/**
 *
 */
OS_EXPORT void ServerConnectionFactoryBase::closeAllConnections()
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    for (SrvConnContainerIter_t iter = mServerConnections.begin(); iter != mServerConnections.end();)
    {
        if (false == deletePushConnection(iter))
            iter++;
    }//end for
}

/**
 *
 */
OS_EXPORT void ServerConnectionFactoryBase::deletePushConnection(const std::wstring& aUri)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter == mServerConnections.end())
        return;
    deletePushConnection(iter);
}

/**
 *
 */
bool ServerConnectionFactoryBase::deletePushConnection(SrvConnContainerIter_t& aIter)
{
    JELOG2(EJavaPush);

    if (SrvConnContainerData::PUSH == aIter->second.connType())
    {
        aIter->second.getConn()->close();
        delete aIter->second.getConn();
        mServerConnections.erase(aIter++);
        return true;
    }
    else if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == aIter->second.connType())
    {
        //MIDlet listens connection so we cannot delete it here.
        aIter->second.setConnType(SrvConnContainerData::NORMAL);
    }
    //This method does nothing for non-push server connection. Non-push
    //connections must be release by releaseConnection operation.
    return false;
}

/**
 *
 */
OS_EXPORT ServerConnection* ServerConnectionFactoryBase::getPushConnection(const std::wstring& aUri)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter == mServerConnections.end())
        return 0;
    if (SrvConnContainerData::NORMAL == iter->second.connType())
        return 0;
    return iter->second.getConn();
}

/**
 *
 */
OS_EXPORT void ServerConnectionFactoryBase::releaseConnection(const std::wstring& aUri)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter == mServerConnections.end())
        return;

    if (SrvConnContainerData::NORMAL == iter->second.connType())
    {
        iter->second.getConn()->close();
        delete iter->second.getConn();
        mServerConnections.erase(iter);
        return;
    }
    else if (SrvConnContainerData::PUSH_LISTEN_BY_MIDLET == iter->second.connType())
    {
        iter->second.getConn()->close();
        iter->second.setConnType(SrvConnContainerData::PUSH);
        return;
    }
    //This operation does nothing for connection which type is PUSH.
}

/**
 *
 */
OS_EXPORT void ServerConnectionFactoryBase::setPendingMsgFlag
(const std::wstring& aUri,bool aPendingMsg)
{
    JELOG2(EJavaPush);
    ScopedLock lockObj(mMutex);

    //LOG1WSTR(EJavaPush,EInfo,"setPendingMsgFlag() URI: %s",aUri);
    //LOG1(EJavaPush,EInfo,"setPendingMsgFlag() aPendingMsg: %d",(int)aPendingMsg);

    SrvConnContainerIter_t iter = mServerConnections.find(aUri);
    if (iter != mServerConnections.end())
    {
        iter->second.setActive(aPendingMsg);
        PendingConnectionListener* tmpListener = iter->second.getPendingConnListener();
        if (0 != tmpListener)
            tmpListener->setPendingStatus(aUri,aPendingMsg);
    }
}