/*
* 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:        
*
*/








#include "wsovivalidatehandler.h"
#include "wsovioauthclient.h"
#include "sendebug.h"
#include "senlogger.h"

class CWSOviHandlerContext;

//---------------------------------------------------------------------------
// Create instance of concrete ECOM interface implementation
//---------------------------------------------------------------------------
//
CWSOviValidateHandler* CWSOviValidateHandler::NewL(TAny* aHandlerCtx)
    {
    
    MSenHandlerContext* handlerCtx =
        reinterpret_cast<MSenHandlerContext*>(aHandlerCtx);
    CWSOviValidateHandler* self   = new (ELeave) CWSOviValidateHandler(*handlerCtx);
    CleanupStack::PushL (self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


//---------------------------------------------------------------------------
// Constructor
//---------------------------------------------------------------------------
//
CWSOviValidateHandler::CWSOviValidateHandler(MSenHandlerContext& aCtx):CSenSessionHandler(aCtx)
    {
    }

//---------------------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------------
//
CWSOviValidateHandler::~CWSOviValidateHandler()
    {
    }

//---------------------------------------------------------------------------
// Second phase construction.
//---------------------------------------------------------------------------
//
void CWSOviValidateHandler::ConstructL()
    {
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,(_L("CWSOviValidateHandler::ConstructL()")));
    }
    

//---------------------------------------------------------------------------
// the most emergent method in message handler interface.
// Each sub-class must implement this method thus providing message processing routine.
//---------------------------------------------------------------------------
//
TInt CWSOviValidateHandler::InvokeL(MSenSessionContext& aCtx)
    {

//getting data from input
    CWSOviServiceSession* pNewSession =
            (CWSOviServiceSession*)aCtx.GetSenRemoteServiceSessionL(
            WSOviContextKeys::KServiceSession());
    if (pNewSession->ProviderID() == KNullDesC8)
        {
        return KErrNone;
        }
//try to find identity provider for curennt webService using its ProviderId
    CSenIdentityProvider* pIdentityProvider = IdentityProviderFromCoreL(
            pNewSession->ProviderID());
    if (!pIdentityProvider)
        {
        return KErrNotFound;
        }
    
    const TBool* onlySharingPtr = ((MSenContext&)aCtx).GetIntL(WSOviContextKeys::KOnlySharing);
    TBool onlySharing;
    if (onlySharingPtr)
        {
        onlySharing = *onlySharingPtr;
        }
    else
        {
        onlySharing = ETrue;
        }
    
    CWSOviOAuthClient* pAuthClient = AuthClientL(pIdentityProvider);
    if (pAuthClient)
            {
            TInt error(KErrNone);
            pAuthClient->SetHandlerCtx(&iHandlerContext);
            //validate session of concrete WebService
            HBufC8* errorMessage = NULL;
            TRAPD(lerror, error = pAuthClient->ValidateL(*pNewSession, errorMessage, onlySharing);)    
            ((MSenContext&)aCtx).Update(WSOviContextKeys::KReAuthNeeded, EFalse);
            if (errorMessage)
                {
                ((MSenContext&)aCtx).Update(WSOviContextKeys::KErrMessage,  *errorMessage);
                }
            delete errorMessage;
            errorMessage = NULL;
            if (lerror) return lerror;
            //if credential expired session will use validator to obtain new
            
            // Core / XML DAO takes ownership of new session (will keep in array of SD):
            // - new session HAS
            //      - credential
            // - if duplicate (equal primary keys) exiAuth, it is deleted
            return error;
            }
       else
            {
            return KErrNotFound;
            }
    
    }
    
SenHandler::THandlerDirection CWSOviValidateHandler::Direction() const
    {
        return SenHandler::EBoth;
    };
SenHandler::THandlerPhase CWSOviValidateHandler::Phase()
    {
        return SenHandler::EValidate;
    };
    
//---------------------------------------------------------------------------
// Obtain or construct Auth client
//---------------------------------------------------------------------------
//
  
CWSOviOAuthClient* CWSOviValidateHandler::AuthClientL(CSenIdentityProvider*& aIdentityProvider)
{
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,(_L("CWSOviValidateHandler::AuthClientL")));

    CWSOviOAuthClient* pAuthClient = NULL;
    //providerId from Identities.xml
    TPtrC8 providerId(KNullDesC8);
    if(aIdentityProvider)
        {
        providerId.Set(aIdentityProvider->ProviderID());
        }

    RPointerArray<CSenWSDescription> serviceDescriptions;
    CleanupClosePushL(serviceDescriptions);
        
    //try to find Auth session in cache,some Auth can be registered
    TInt retVal(KErrNone);
    
    TRAPD(error, retVal = iHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, KWSOviAuthenticationServiceContract()));
    if(!retVal&&!error)
        {
        RPointerArray<CSenWSDescription> matches;
        CleanupClosePushL(matches);
        
        for(TInt i = 0; i < serviceDescriptions.Count(); i++)
            {
            //select XMLDescription from DAO where contract = Auth, so we can cast
            if (serviceDescriptions[i]->DescriptionClassType() == MSenServiceDescription::EOviOAuthClient)
                {
                pAuthClient = (CWSOviOAuthClient*)serviceDescriptions[i];
                if(providerId.Length()>0)
                    {
                    TPtrC8 providerIDFromDescription = pAuthClient->ProviderID();
                    if(providerIDFromDescription == providerId)
                        {
                        matches.AppendL(pAuthClient);
                        }
                    }
                else
                    {
                    matches.AppendL(pAuthClient);
                    }                
                }
            }
        if(matches.Count())
            {
            pAuthClient =
                reinterpret_cast<CWSOviOAuthClient*>(matches[0]);
            pAuthClient->SetAccount(aIdentityProvider);
            }
        else
            {
            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,(_L("CWSOviValidateHandler::AuthClient - No matching AuthClient  description available!")));
            pAuthClient = NULL;
            }
    
        //if we find multi Auth client (different only with lifetime, probably Secure Context Token lifetime)
        if(matches.Count() > 1)
            {
            // search for a instance with longest validity
            for(TInt i = matches.Count()-1; i > 0 ; i--)
                {
                CWSOviOAuthClient* pNewerAuthClient =
                  reinterpret_cast<CWSOviOAuthClient*>(matches[i]);
                CWSOviServiceSession* newerSession = (CWSOviServiceSession*)pNewerAuthClient->ServiceSession();
                CWSOviServiceSession* session = (CWSOviServiceSession*)pAuthClient->ServiceSession();
                
				if(newerSession && session) // AuthClient Session was not set, if not validated 
					{
					if(newerSession->ValidUntilL() > session->ValidUntilL())
					  	{
					    pAuthClient = pNewerAuthClient;
					    pAuthClient->SetAccount(aIdentityProvider);
					    }
					}
                }
            }
            CleanupStack::PopAndDestroy(2, &serviceDescriptions);
        }
    else
        {
          CleanupStack::PopAndDestroy(&serviceDescriptions);
        }
    return pAuthClient;
}

//---------------------------------------------------------------------------
// Create IdentityProvider from CoreManager
//---------------------------------------------------------------------------
//
CSenIdentityProvider* CWSOviValidateHandler::IdentityProviderFromCoreL(
                                            const TDesC8& aProviderID)
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"CWSOviValidateHandler::IdentityProviderLFromCore");
    CSenIdentityProvider* pIdentityProvider = NULL;
    if(aProviderID.Length() > 0)
        {
        CDesC8ArrayFlat* array = new (ELeave) CDesC8ArrayFlat(1);
        CleanupStack::PushL(array);
        array->AppendL(aProviderID);
        pIdentityProvider = iHandlerContext.GetSenCoreServiceManager()->
                IdentityProviderL(*array, ETrue);
        CleanupStack::PopAndDestroy(array);
        }
    return pIdentityProvider;
    }

//---------------------------------------------------------------------------
// Init implementation
//---------------------------------------------------------------------------
//
TInt CWSOviValidateHandler::InitL(MSenHandlerContext& aCtx)
    {
    iHandlerContext = aCtx;
    return KErrNone;
    }
RFileLogger* CWSOviValidateHandler::Log() const
    {
    RFileLogger* pLog = NULL;
    TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )
    return pLog;
    }
MSenHandlerContext& CWSOviValidateHandler::HandlerContext()
	{
	return iHandlerContext;
	}
// END OF FILE