/* -*- C++ -*- */
/*
 *   Copyright 2003-2004 The Apache Software Foundation.
 *
 *   Licensed 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.
 *
 *
 * @author Susantha Kumara (skumara@virtusa.com)
 *
 */

// !!! This include file must be first thing in file !!!
#include "../platforms/PlatformAutoSense.hpp"

#include <axis/AxisException.hpp>

#include "HandlerPool.h"
#include "AppScopeHandlerPool.h"
#include "RequestScopeHandlerPool.h"
#include "SessionScopeHandlerPool.h"
#include "../wsdd/WSDDDeployment.h"

#include "../common/AxisTrace.h"

extern AXIS_CPP_NAMESPACE_PREFIX AppScopeHandlerPool* g_pAppScopeHandlerPool;
extern AXIS_CPP_NAMESPACE_PREFIX RequestScopeHandlerPool* g_pRequestScopeHandlerPool;
extern AXIS_CPP_NAMESPACE_PREFIX SessionScopeHandlerPool* g_pSessionScopeHandlerPool;
extern AXIS_CPP_NAMESPACE_PREFIX WSDDDeployment* g_pWSDDDeployment;

AXIS_CPP_NAMESPACE_START

HandlerPool::
HandlerPool ()
{
}

HandlerPool::
~HandlerPool ()
{
    logEntryEngine("HandlerPool::~HandlerPool")

    for (list <HandlerChain*>::iterator it = m_ChainStore.begin (); it != m_ChainStore.end (); it++)
    {
        delete (*it);
    }
    
    logExit()
}

int HandlerPool::
getHandler (BasicHandler** ppHandler, string & sSessionId, int nScope, int nLibId)
{
    logEntryEngine("HandlerPool::getHandler")

    *ppHandler = NULL;
    int Status = AXIS_FAIL;

    switch (nScope)
    {
        case AH_APPLICATION:
            do
            {
                Status = g_pAppScopeHandlerPool->getInstance (ppHandler, nLibId);
                if (AXIS_SUCCESS == Status)
                    break;
                else if (Status == SERVER_ENGINE_HANDLER_BEING_USED)
                {             
                    //block this thread not this object
                    PLATFORM_SLEEP(0);
                }
                else
                    break;
            }
            while (Status == SERVER_ENGINE_HANDLER_BEING_USED);
            
            break;
            
        case AH_SESSION:
            Status = g_pSessionScopeHandlerPool->getInstance (sSessionId, ppHandler, nLibId);
            break;
            
        case AH_REQUEST:
            Status = g_pRequestScopeHandlerPool->getInstance (ppHandler, nLibId);
            break;
    }
    
    logExitWithReturnCode(Status)
    
    return Status; 
}

int HandlerPool::
poolHandler (string &sSessionId, BasicHandler* pHandler, int nScope, int nLibId, bool bWebService)
{
    logEntryEngine("HandlerPool::poolHandler")

    switch (nScope)
    {
        case AH_APPLICATION:
            g_pAppScopeHandlerPool->putInstance (pHandler, nLibId);
            break;
        case AH_SESSION:
            g_pSessionScopeHandlerPool->putInstance (sSessionId, pHandler, nLibId);
            break;
        case AH_REQUEST:
            g_pRequestScopeHandlerPool->putInstance (pHandler, nLibId, bWebService);
            break;
    }
    
    logExitWithReturnCode(AXIS_SUCCESS)
    
    return AXIS_SUCCESS;
}

int HandlerPool::
getGlobalRequestFlowHandlerChain (HandlerChain** ppChain, string & sSessionId)
{
    logEntryEngine("HandlerPool::getGlobalRequestFlowHandlerChain")

    int Status = AXIS_SUCCESS;

    const WSDDHandlerList* pHandlerList = g_pWSDDDeployment->getGlobalRequestFlowHandlers ();
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status; 
}

int HandlerPool::
getGlobalResponseFlowHandlerChain (HandlerChain** ppChain, string &sSessionId)
{
    logEntryEngine("HandlerPool::getGlobalResponseFlowHandlerChain")

    int Status = AXIS_SUCCESS;

    const WSDDHandlerList *pHandlerList = g_pWSDDDeployment->getGlobalResponseFlowHandlers ();
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status; 
}

int HandlerPool::
getTransportRequestFlowHandlerChain (HandlerChain** ppChain, string &sSessionId, AXIS_PROTOCOL_TYPE Protocol)
{
    logEntryEngine("HandlerPool::getTransportRequestFlowHandlerChain")

    int Status = AXIS_SUCCESS;

    const WSDDHandlerList* pHandlerList = g_pWSDDDeployment->getTransportRequestFlowHandlers (Protocol);
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status; 
}

int HandlerPool::
getTransportResponseFlowHandlerChain (HandlerChain** ppChain, string & sSessionId, AXIS_PROTOCOL_TYPE Protocol)
{
    logEntryEngine("HandlerPool::getTransportResponseFlowHandlerChain")

    int Status = AXIS_SUCCESS;

    const WSDDHandlerList* pHandlerList = g_pWSDDDeployment->getTransportResponseFlowHandlers (Protocol);
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status;   
}

int HandlerPool::
getRequestFlowHandlerChain (HandlerChain** ppChain, string &sSessionId, const WSDDService* pService)
{
    logEntryEngine("HandlerPool::getRequestFlowHandlerChain")

    int Status = AXIS_SUCCESS;

    const WSDDHandlerList* pHandlerList = pService->getRequestFlowHandlers ();
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status;    
}

int HandlerPool::
getResponseFlowHandlerChain (HandlerChain** ppChain, string &sSessionId, const WSDDService* pService)
{
    logEntryEngine("HandlerPool::getResponseFlowHandlerChain")
    
    int Status = AXIS_SUCCESS;

    const WSDDHandlerList* pHandlerList = pService->getResponseFlowHandlers ();
    if (pHandlerList)
        Status = getHandlerChain (sSessionId, ppChain, pHandlerList);
    else
        *ppChain = NULL;
    
    logExitWithReturnCode(Status)
    
    return Status;
}

int HandlerPool::
getHandlerChain (string &sSessionId, HandlerChain** ppChain, const WSDDHandlerList* pHandlerList)
{
    logEntryEngine("HandlerPool::getHandlerChain")

    Lock l(this);
    *ppChain = NULL;
    HandlerChain* pChain = NULL;
    
    // check m_ChainStore to get a HandlerChain
    if (!m_ChainStore.empty ())
    {
        pChain = m_ChainStore.front ();
        m_ChainStore.pop_front ();
        pChain->init ();
    }
    else
        pChain = new HandlerChain ();

    WSDDHandler* pWSDDH = NULL;
    BasicHandler* pBH = NULL;
    int Status = AXIS_SUCCESS;

    for (WSDDHandlerList::const_iterator it = pHandlerList->begin (); it != pHandlerList->end (); it++)
    {
        pWSDDH = (*it);
        if ((Status = getHandler (&pBH, sSessionId, pWSDDH->getScope (), pWSDDH->getLibId ())) == AXIS_SUCCESS)
        {
            if (0 != pBH->_functions)
            {
                /* C Handler */
            }
            else if (0 != pBH->_object)
            {
                if (NORMAL_HANDLER == ((Handler*) (pBH->_object))->getType ())
                {
                    ((Handler*) (pBH->_object))-> setOptionList (pWSDDH->getParameterList ());
                    pChain->addHandler (pBH, pWSDDH->getScope (), pWSDDH->getLibId ());
                }
                else
                {
                    Status = SERVER_ENGINE_WRONG_HANDLER_TYPE;
                    break;
                }
            }
        }
        else
            break;
    }
    
    
    if (Status != AXIS_SUCCESS) //some failure so undo whatever done here
    {
        string nosession = SESSIONLESSHANDLERS;
        for (pChain->m_itCurrHandler = pChain->m_HandlerList.begin ();
             pChain->m_itCurrHandler != pChain->m_HandlerList.end ();
               pChain->m_itCurrHandler++)
        {
            if ((*pChain->m_itCurrHandler).m_pHandler != NULL)
            {
                poolHandler (nosession, (*pChain->m_itCurrHandler).m_pHandler,
                    (*pChain->m_itCurrHandler).m_nScope,
                    (*pChain->m_itCurrHandler).m_nLibId);
            }
        }
        pChain->fini ();
        m_ChainStore.push_back (pChain);
    }
    else
        *ppChain = pChain;
    
    logExitWithReturnCode(Status)
    
    return Status;
}

void HandlerPool::
poolHandlerChain (HandlerChain* pChain, string &sSessionId)
{
    logEntryEngine("HandlerPool::poolHandlerChain")

    for (pChain->m_itCurrHandler = pChain->m_HandlerList.begin ();
        pChain->m_itCurrHandler != pChain->m_HandlerList.end ();
        pChain->m_itCurrHandler++)
    {
        if ((*pChain->m_itCurrHandler).m_pHandler != NULL)
        {
            poolHandler (sSessionId, (*pChain->m_itCurrHandler).m_pHandler,
                (*pChain->m_itCurrHandler).m_nScope, 
                (*pChain->m_itCurrHandler).m_nLibId);
        }
    }
    pChain->fini ();

    Lock l(this);
    m_ChainStore.push_back (pChain);
    
    logExit()
}

int HandlerPool::
getWebService( BasicHandler ** ppHandler, string & sSessionId, const WSDDHandler * pService)
{
    logEntryEngine("HandlerPool::getWebService")

    int Status = getHandler( ppHandler, sSessionId, pService->getScope(), pService->getLibId());

    if( Status == AXIS_SUCCESS)
    {
        if( NULL != (*ppHandler)->_functions)
        // C web service 
        {
            /*if (AXIS_SUCCESS !=
                (Status =
                (*ppHandler)->_functions->init ((*ppHandler)->_object)))
            {
                (*ppHandler)->_functions->fini ((*ppHandler)->_object);
                poolHandler (sSessionId, *ppHandler, pService->getScope (),
                    pService->getLibId ());
                *ppHandler = NULL;
            }*/
        }
        else if( NULL == (*ppHandler)->_object)
        {
            Status = AXIS_FAIL;
        }
        else
        // C++ web service 
        {
            /*if (AXIS_SUCCESS !=
                (Status =
                ((HandlerBase *) (*ppHandler)->_object)->init ()))
            {
                ((HandlerBase *) (*ppHandler)->_object)->fini ();
                poolHandler (sSessionId, *ppHandler, pService->getScope (),
                    pService->getLibId ());
                *ppHandler = NULL;
            }*/
        }
    }
    
    logExitWithReturnCode(Status)

    return Status;
}

void HandlerPool::
poolWebService (string &sSessionId, BasicHandler* pHandler, const WSDDHandler * pHandlerInfo)
{
    logEntryEngine("HandlerPool::poolWebService")

    poolHandler (sSessionId, pHandler, pHandlerInfo->getScope (), pHandlerInfo->getLibId (), true);
    
    logExit()
}

AXIS_CPP_NAMESPACE_END