/*
* 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 the License "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:  Multi threaded tests on AuthServer.
*
*/


#include "tAuthSvrStep.h"
#include "authserver/authclient.h"
#include "authserver/authmgrclient.h"



using namespace AuthServer;

//Active object for registration
class CMultiThreadedRegisterActive : public CActive
    {
    public:
     CMultiThreadedRegisterActive(RAuthMgrClient& aClient, HBufC* aIdentityString, CIdentity*& aResult) : 
         CActive(EPriorityNormal),
         iFirstTime(true),
         iClient(aClient), 
         iResult(aResult),
         iIdentityString(aIdentityString),
         iErr(KErrNone)
        {
        CActiveScheduler::Add(this);
        }
    ~CMultiThreadedRegisterActive()
        {
        delete iIdentityString; 
        }
    void doReg()
        {
        SetActive();        
        TRequestStatus* status = &iStatus;
        User::RequestComplete(status, KErrNone);
        iFirstTime = ETrue;
        }
        void DoCancel() 
        {
        }
     void RunL() 
        {
        iErr = iStatus.Int();
        if (iFirstTime)
            {
            SetActive();
            iStatus = KRequestPending;
            iClient.RegisterIdentityL(iResult, *iIdentityString, iStatus);
            iFirstTime = false;
            }
        else
            {
            iErr = iStatus.Int();
            RDebug::Printf("iErr = %d", iErr);
            CActiveScheduler::Stop();
            }
        }
        
    TBool iFirstTime;
    RAuthMgrClient& iClient;
    CIdentity*& iResult;
    HBufC* iIdentityString;
    TInt iErr;
    };

CTMultiThreaded::~CTMultiThreaded()
	{}

CTMultiThreaded::CTMultiThreaded(CTAuthSvrServer& aParent): iParent(aParent)

	{
	
	SetTestStepName(KTMultiThreadedTest);
	}

TVerdict CTMultiThreaded::doTestStepPreambleL()

	{
	CTStepActSch::doTestStepPreambleL();	
	return TestStepResult();
	}

TVerdict CTMultiThreaded::doTestStepPostambleL()

    {
    
    CTStepActSch::doTestStepPostambleL();
    return TestStepResult();
    }

TVerdict CTMultiThreaded::doTestStepL()
	{
	SetTestStepResult(EPass);
	Logger().ShareAuto();
	//Initialize AuthServer.
	InitAuthServerFromFileL();  
	
	
	//Setup two threads which request for registration concurrently.    
	//Create first thread.
	RThread firstThread;
	TInt err(0);
	TThreadParams firstThreadParams;
	err = firstThread.Create( _L("First Thread"), (TThreadFunction)runMultiThreadedTest, 
                                    KDefaultStackSize, KMinHeapSize, 1024*1024 /*Max heap size*/, &firstThreadParams);
	if(err != KErrNone)
	    {
	    ERR_PRINTF2(_L("Couldn't start first thread. Error = %d"), err);
	    SetTestStepResult(EFail);
	    return TestStepResult();
	    }
	    
	// Setup the requeststatus for firstThread completion notification.
	TRequestStatus firstThreadFinishStatus;
	firstThread.Logon(firstThreadFinishStatus);
	
	
	
	//Setup the second thread similarly.
	RThread secondThread;
	TThreadParams secondThreadParams;
    err = secondThread.Create( _L("Second Thread"), (TThreadFunction)runMultiThreadedTest, 
									KDefaultStackSize, KMinHeapSize, 1024*1024 /*Max heap size*/, &secondThreadParams);
    if(err != KErrNone)
        {
        ERR_PRINTF2(_L("Couldn't start second thread. Error = %d"), err);
        SetTestStepResult(EFail);
        return TestStepResult();
        }
        
    // Setup the requeststatus for secondThread completion notification.
    TRequestStatus secondThreadFinishStatus;
    secondThread.Logon(secondThreadFinishStatus);
    
    //Resume both threads.
	firstThread.Resume();   
	secondThread.Resume();   
	
	//Wait for either request to complete.
	User::WaitForRequest(firstThreadFinishStatus, secondThreadFinishStatus );     
	
	//Now, wait for the unfinished thread.
	User::WaitForRequest(firstThreadFinishStatus == KRequestPending? firstThreadFinishStatus:secondThreadFinishStatus);
	
	INFO_PRINTF1(_L("Both Threads completed."));
	INFO_PRINTF2(_L("First thread completed with %d."), firstThreadParams.result);
	INFO_PRINTF2(_L("Second thread completed with %d."), secondThreadParams.result);
	
	if((firstThreadParams.result != KErrServerBusy && secondThreadParams.result != KErrNone) &&
	        (firstThreadParams.result != KErrNone && secondThreadParams.result != KErrServerBusy))
	    {
	    SetTestStepResult(EFail);
	    }
	firstThread.Close();
	secondThread.Close();
	return TestStepResult();
	}



void CTMultiThreaded::runMultiThreadedTest(TThreadParams* aParams)
    {
    CTrapCleanup* cleanup = CTrapCleanup::New();
    CActiveScheduler* sched(0);
    
    TRAPD(err, sched = new (ELeave) CActiveScheduler);
    if(err != KErrNone)
        {
        delete cleanup;
        User::Exit(err);
        }
    CActiveScheduler::Install(sched); 
   
    
    /* Switch case can be added here to generalize this function to run any method.
     * For now, only registration is called.
     */
    
    TRAPD(ret,doRegisterL(*aParams));
	
	RDebug::Printf("doRegisterL returned %d", ret);
    
    delete cleanup;
    delete sched;
    }


void CTMultiThreaded::doRegisterL(TThreadParams& aParams)
    {
    _LIT(KIdString, "User1");
    
    RAuthMgrClient client;
    User::LeaveIfError(client.Connect());
    CleanupClosePushL(client);
    
    HBufC* identityString = KIdString().AllocLC();
    CIdentity* identity1 = 0;
    
    CMultiThreadedRegisterActive* active = new (ELeave)CMultiThreadedRegisterActive(client, identityString, identity1);
    CleanupStack::PushL(active);
    active->doReg();
    CActiveScheduler::Start();
    
    //Store the error code in aParams.
    aParams.result = active->iErr;
    if(aParams.result == KErrNone)
        {
        RDebug::Printf("Registered new Identity! Id = %x", identity1->Id());
        }
    else
        {
        RDebug::Printf("Registration Failed !");
        }
    
    delete identity1;
    
    CleanupStack::Pop(3, &client);
    }