/*

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

*

*/

#include <bautils.h>

#include <s32file.h>

#include <test/testexecutelog.h>

#include "authserver/authmgrclient.h"

#include "authserver/identity.h"

#include "tauthcliservstep.h"

using namespace AuthServer;

class CRegActive : public CActive

    {

    public:

    CRegActive(RAuthMgrClient& aClient, CIdentity*& aResult, TBool aStop = ETrue) : 

         CActive(EPriorityNormal),

         iFirstTime(true),

         iClient(aClient), 

         iResult(aResult),

         iStop(aStop)

        {

        CActiveScheduler::Add(this);

        }

    void doReg()

        {

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iFirstTime = ETrue;				

        }

        void DoCancel() 

        {

        }

     void RunL() 

        {

        if (iFirstTime)

            {

			SetActive();

            iStatus = KRequestPending;

            iClient.RegisterIdentityL(iResult, _L("SOMENAME"), iStatus);

            iFirstTime = false;

            }

        else

            {

            if (iStop)

                {

                CActiveScheduler::Stop();

                }

            iErr = iStatus.Int();

			}

        }

        TBool iFirstTime;

        RAuthMgrClient& iClient;

        CIdentity*& iResult;

        TBool iStop;

        TInt iErr;

    };

class CTrainActive : public CActive

    {

    public:

    CTrainActive(RAuthMgrClient& aClient, TBool aStop = ETrue) : 

         CActive(EPriorityNormal),

         iClient(aClient),

		 iResult(EFail),

         iRunCount(0),

         iStop(aStop)

        {

        CActiveScheduler::Add(this);

        }

    void doTrain() 

        {

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iRunCount = 0;

        }

        void DoCancel() 

        {

        }

     void RunL() 

        {

        iErr = iStatus.Int();

        if (iStatus.Int() != KErrNone)

            {

            }

		switch (iRunCount)

		  {

		  case 0:

            iStatus = KRequestPending;

			iAe = AuthExpr(0x10274104);

			iId = 0;

			iClient.AuthenticateL(*iAe, 10, EFalse, EFalse, iId, iStatus);

			SetActive();

			break;

		  case 1:

			delete iAe;

			delete iId;

            iStatus = KRequestPending;

            iClient.TrainPlugin(22, 0x10274104, iStatus);

			SetActive();

			break;

   		  case 2:

			iResult = iStatus.Int() == KErrNone ? EPass : EFail;

            iErr = iStatus.Int();

			if (iStop)

                {

                CActiveScheduler::Stop();

                }

			break;

     	  default:

			iResult = EFail;

			if (iStop)

			    {

			    CActiveScheduler::Stop();

			    }

		    }

		  ++iRunCount;

          }

	RAuthMgrClient& iClient;

	TVerdict iResult;

	TInt iRunCount;

	CAuthExpression* iAe;

	CIdentity* iId;

    TBool iStop;

    TInt iErr;

    };

class CTrainActive2 : public CActive

    {

    public:

    CTrainActive2(RAuthMgrClient& aClient, TBool aStop = ETrue) : 

         CActive(EPriorityNormal),

         iClient(aClient),

         iRunCount(0),

         iStop(aStop)

        {

        CActiveScheduler::Add(this);

        }

    void doTrain() 

        {

        SetActive();		

		iClient.TrainPlugin(22, 0x10274105, iStatus);

		}

	void DoCancel() 

        {

        }

	void RunL()

	    {

		iErr = iStatus.Int();

		if (iStop)

		    {

			CActiveScheduler::Stop();

		    }

	    }

	RAuthMgrClient& iClient;

	TInt iRunCount;

	CAuthExpression* iAe;

	CIdentity* iId;

    TBool iStop;

    TInt iErr;

    };

class CCancelActive : public CActive

    {

    public:

    CCancelActive(RAuthMgrClient& aClient) : 

         CActive(EPriorityNormal),

         iClient(aClient),

		 iResult(EFail),

         iRunCount(0)

        {

        CActiveScheduler::Add(this);

        }

    void doIdCancel() 

        {

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iMode = 1;

		iRunCount = 0;

        }

    void doRegCancel() 

        {

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iMode = 2;

		iRunCount = 0;

        }

    void doTrainCancel() 

        {

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iMode = 0;

		iRunCount = 0;

        }

	void DoCancel() 

        {

        }

     void RunL() 

        {

        if (iStatus.Int() != KErrNone)

            {

			  //RDebug::Printf("CCancelActive error: %d", iStatus.Int());

            }

		switch (iRunCount)

		  {

		  case 0:

            iStatus = KRequestPending;

			iAe = AuthExpr(0x10274105);

			iId = 0;

			switch (iMode)

			  {

			  case 2:

				iClient.RegisterIdentityL(iId, _L("RegCancelID"), iStatus);

				break;

			  case 1:

				iClient.AuthenticateL(*iAe, 0, EFalse, ETrue, iId, iStatus);

			    break;

			  case 0:

				iClient.TrainPlugin(22, 0x10274105, iStatus);

				break;

			  }

			SetActive();

            User::After(1000000);

            iClient.Cancel();

			break;

		  case 1:

			//iStatus = KRequestPending;

			delete iAe;

			delete iId;

            //SetActive();

		    //break;

   		  case 2:

			iResult = iStatus.Int() == KErrCancel ? EPass : EFail;

            CActiveScheduler::Stop();

			break;

     	  default:

			iResult = EFail;

            CActiveScheduler::Stop();

		  }

		++iRunCount;

        }

	RAuthMgrClient& iClient;

	TVerdict iResult;

	TInt iRunCount;

	CAuthExpression* iAe;

	CIdentity* iId;

	TInt iMode;

    };

CTStepMgrClient::CTStepMgrClient()

	{

	SetTestStepName(KTStepMgrClient);

	}

TBool CTStepMgrClient::TestMultiRegisterL(RAuthMgrClient& client)

    {

    CIdentity* result = 0;

    CRegActive active(client, result);

    CIdentity* result2 = 0;

    RAuthMgrClient client2;

    User::LeaveIfError(client2.Connect());

    CleanupClosePushL(client2);

    CRegActive active2(client2, result2, EFalse);

    active.doReg();		

    active2.doReg();		

	CActiveScheduler::Start();

    TEST(active.iErr == KErrNone);

    TEST(active2.iErr == KErrServerBusy);

    delete result;

    delete result2;

    CleanupStack::PopAndDestroy(&client2);

	return ETrue;

    }

TBool CTStepMgrClient::TestRegister(RAuthMgrClient& client)

  {

    CIdentity* result = 0;

    CRegActive active(client, result);

    active.doReg();		

	CActiveScheduler::Start();

    if (result == 0)

        {

        return EFalse;

        }

	INFO_PRINTF3(_L("Id = %d , KeyLength = %d\n"), result->Id(), result->Key().KeyData().Size());

	delete result;

	result = 0;

    return ETrue;

  }

TBool CTStepMgrClient::TestMultiTrainL(RAuthMgrClient& client)

  {

    CTrainActive2 active(client);

    active.doTrain();		

    RAuthMgrClient client2;

    User::LeaveIfError(client2.Connect());

    CleanupClosePushL(client2);

    CTrainActive2 active2(client2, EFalse);

    active2.doTrain();		

	CActiveScheduler::Start();

	TEST(active.iErr == KErrAuthServPluginCancelled); // blocking plugin returns

	                                                  // cancelled if left to

	                                                  // complete

    TEST(active2.iErr == KErrServerBusy);

	CleanupStack::PopAndDestroy(&client2);	

	INFO_PRINTF3(_L("Training Result (%d,%d)\n"),

	     active.iErr,

	     active2.iErr);

	return true;

  }

TBool CTStepMgrClient::TestTrain(RAuthMgrClient& client)

  {

    CTrainActive active(client);

    active.doTrain();		

	CActiveScheduler::Start();

	INFO_PRINTF2(_L("Training Result = %d\n"), active.iResult == EPass);

	return active.iResult == EPass;

  }

TBool CTStepMgrClient::TestCancellation(RAuthMgrClient& client)

  {

    CCancelActive active(client);

    active.doTrainCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);

    active.doTrainCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);

    active.doTrainCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);

    //User::After(5000000);

    active.doIdCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Id Cancel Result = %d\n"), active.iResult == EPass);

    active.doIdCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Id Cancel Result = %d\n"), active.iResult == EPass);

	active.doRegCancel();		

	CActiveScheduler::Start();

	TEST(active.iResult == EPass);

	INFO_PRINTF2(_L("Registration Cancel Result = %d\n"), active.iResult == EPass);

	return active.iResult == EPass;

  }

TVerdict CTStepMgrClient::doTestStepL()

	{

	TInt r = 0;

	if (TestStepResult() != EPass)

		{

		INFO_PRINTF1(_L("Previous step failed"));

		return TestStepResult();

		}

	WaitForServerToReleaseDb();

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName sysDriveName (sysDrive.Name());

	_LIT(KDbSrcFile ,"\\authdb0.db");

	TBuf<64> dbSrcFileName (sysDriveName);

	dbSrcFileName.Append(KDbSrcFile);

	TBuf<128> dbName(KDbName);

	dbName[0] = 'A' + sysDrive;	

	r = BaflUtils::CopyFile(iFs, dbSrcFileName, dbName);

	INFO_PRINTF2(_L("File copy returned %d"), r);

	User::LeaveIfError(r);

	__UHEAP_MARK;

    SetTestStepResult(EPass);

	CActiveScheduler::Install(iActSchd);

	RAuthMgrClient mgrclient;

	User::LeaveIfError(mgrclient.Connect());

	CleanupClosePushL(mgrclient);

   	mgrclient.RemoveIdentityL(2);

	RIdentityIdArray ids;

	mgrclient.IdentitiesL(ids);

	CleanupClosePushL(ids);

	TESTL(ids.Count() == 3);

	// ensure each expected identity occurs once.

	// (This technique is simple but doesn't generalise.)

	TInt sum = 0;

	for (TInt i = 0; i < 3; ++i)

		{

		TIdentityId id = ids[i];

		TESTL(id == 1 || id == 3 || id == 22);

		sum += id;

		}

	TESTL(sum == 1 + 3 + 22);

	CleanupStack::PopAndDestroy(&ids);

	TEST(TestRegister(mgrclient));

	mgrclient.IdentitiesL(ids);

	CleanupClosePushL(ids);

	TEST(ids.Count() == 4);

	CleanupStack::PopAndDestroy(&ids);

	TEST(TestTrain(mgrclient));

	INFO_PRINTF1(_L("Testing cancellation"));

    TEST(TestCancellation(mgrclient));

    INFO_PRINTF1(_L("Testing simultaneous registrations are blocked"));

    TEST(TestMultiRegisterL(mgrclient));

    INFO_PRINTF1(_L("Testing simultaneous trainings are blocked"));

    TestMultiTrainL(mgrclient);

	// Last plugin can't be removed 

	TRAPD(err, mgrclient.ForgetPluginL(22,0x10274104));

	TEST(err == KErrAuthServCanNotRemoveLastPlugin);

	CleanupStack::PopAndDestroy(1, &mgrclient);

	__UHEAP_MARKEND;	

	return EPass;

	}