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

/**
@file

CABDataOwnerCallbackImplementation implementation
*/

#include "abdataowner.h"
#include "abtesterlog.h"
#include <connect/sbdefs.h>

namespace conn
	{
	const TInt KSourceSize = 8000;
	
	CABDataOwnerCallbackImplementation* CABDataOwnerCallbackImplementation::NewL(TSecureId aID)
		{
		CABDataOwnerCallbackImplementation* self = new (ELeave) CABDataOwnerCallbackImplementation(aID);
		//CleanupStack::PushL(self);
		//self->ConstructL();
		//CleanupStack::Pop(self);
		return self;
		}
		
	
		
	CABDataOwnerCallbackImplementation::CABDataOwnerCallbackImplementation(TSecureId aID) : iABClient(NULL), iVersion(1,0,0), iProxy(EFalse), iSourceSize(KSourceSize), iID(aID)
		{
		}	
		
	void CABDataOwnerCallbackImplementation::SetABClient(CActiveBackupClient* aABClient)
		{
		iABClient = aABClient;
		}
		
	CABDataOwnerCallbackImplementation::~CABDataOwnerCallbackImplementation()
		{
		delete iABClient;
		delete iSnapshot;
		delete iData;
		}
		
	// from MActiveBackupDataClient - callbacks
	void CABDataOwnerCallbackImplementation::AllSnapshotsSuppliedL()
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::AllSnapshotsSuppliedL()", iID.iId);
		}
		
	void CABDataOwnerCallbackImplementation::ReceiveSnapshotDataL(TDriveNumber aDrive, TDesC8& aBuffer, TBool /*aLastSection*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::ReceiveSnapshotDataL()", iID.iId);
		// Create or append a buffer containing the snapshot
		if (!iSnapshot)
			{
			iSnapshot = CABData::NewL(aDrive);
			}

		iSnapshot->AddDataL(aBuffer);
		}
		
	TUint CABDataOwnerCallbackImplementation::GetExpectedDataSize(TDriveNumber /*aDrive*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetExpectedDataSize()", iID.iId);
			
		return iSourceSize;
		}
		
	void CABDataOwnerCallbackImplementation::GetSnapshotDataL(TDriveNumber /*aDrive*/, TPtr8& aBuffer, TBool& aFinished)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetSnapshotDataL()", iID.iId);
		aBuffer.Append(KABTestSnapshot());
		
		aFinished = ETrue;
		}
		
	void CABDataOwnerCallbackImplementation::InitialiseGetBackupDataL(TDriveNumber /*aDrive*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseGetBackupData()", iID.iId);
		iOffset = 0;

		if (!iSnapshot)
			{
			iFillChar = 66;
			}
		else
			{
			iFillChar = 73;
			}
		}
		
	void CABDataOwnerCallbackImplementation::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetBackupDataSectionL()", iID.iId);
		
		FillBuffer(aBuffer, aFinished);
		}
		
	void CABDataOwnerCallbackImplementation::InitialiseRestoreBaseDataL(TDriveNumber aDrive)
		{
		__LOG("CABDataOwnerCallbackImplementation::InitialiseRestoreBaseDataL()");
//		WaitForMillisecondsL(KABInitTime);

		iData = CABData::NewL(aDrive);
		}
		
	void CABDataOwnerCallbackImplementation::RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreBaseDataSectionL()", iID.iId);

		// append a buffer containing the base data
		iData->AddDataL(aBuffer);
		
		if (aFinished)
			{
			ValidateRestoredData();
		
			delete iData;
			iData = NULL;
			}
		}
		
	void CABDataOwnerCallbackImplementation::InitialiseRestoreIncrementDataL(TDriveNumber aDrive)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseRestoreIncrementDataL()", iID.iId);
		if (!iSnapshot)
			{
			User::Leave(KErrCorrupt);
			}

		if (!iData)
			{
			iData = CABData::NewL(aDrive);
			}
		}
		
	void CABDataOwnerCallbackImplementation::RestoreIncrementDataSectionL(TDesC8& aBuffer, TBool aFinished)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreIncrementDataSectionL()", iID.iId);

		iData->AddDataL(aBuffer);
		
		if (aFinished)
			{
			ValidateRestoredData();
		
			delete iData;
			iData = NULL;
			}
		}
		
	void CABDataOwnerCallbackImplementation::RestoreComplete(TDriveNumber /*aDrive*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreComplete()", iID.iId);
		}
		
	void CABDataOwnerCallbackImplementation::TerminateMultiStageOperation()
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::TerminateMultiStageOperation()", iID.iId);
		// We also don't do anything here until we start testing multipart?
		}
		
	TUint CABDataOwnerCallbackImplementation::GetDataChecksum(TDriveNumber /*aDrive*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetDataChecksum()", iID.iId);
		return 0;
		}

	void CABDataOwnerCallbackImplementation::WaitForMillisecondsL(TInt aMilliseconds)
		{
		RTimer timer;
		TRequestStatus status;
		
		User::LeaveIfError(timer.CreateLocal());
		
		timer.After(status, aMilliseconds);
		User::WaitForRequest(status);
		}

	TBool CABDataOwnerCallbackImplementation::ValidateRestoredData()
		{
		TBool result = ETrue;

		__LOG3("[0x%08x]: Received data : %d %c's", iID.iId, (*iData)().Size(), (*iData)()[0]);

		return result;
		}
		
	TBool CABDataOwnerCallbackImplementation::ValidateRestoredSnapshot()
		{
		TBool result = ETrue;
		
		if ((*iSnapshot)() != KABTestSnapshot())
			{
			__LOG1("[0x%08x]: Snapshot was NOT received correctly", iID.iId);
			result = EFalse;
			}
		else
			{
			__LOG1("[0x%08x]: Snapshot was received correctly", iID.iId);
			}
			
		return result;
		}
		
	void CABDataOwnerCallbackImplementation::InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber /*aDrive*/)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseGetProxyBackupDataL()", iID.iId);
		__LOG2("[0x%08x]: Proxy data about to be requested for SID 0x%08x", iID.iId, aSID.iId);
		iProxy = ETrue;
		iOffset = 0;
		
		iFillChar = 80;		// 'P'
		}

	void CABDataOwnerCallbackImplementation::InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber aDrive)
		{
		__LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseRestoreProxyBaseDataL()", iID.iId);
		__LOG2("[0x%08x]: Proxy data about to be restored for SID 0x%08x", iID.iId, aSID.iId);
		iProxy = ETrue;
		iData = CABData::NewL(aDrive);
		}
		
	void CABDataOwnerCallbackImplementation::FillBuffer(TDes8& aDes, TBool& aFinished)
		{
		TInt bytesToAdd;
		TChar fillChar(iFillChar);
		
		if ((iOffset + aDes.MaxSize()) < iSourceSize)
			{
			aFinished = EFalse;
			bytesToAdd = aDes.MaxSize();
			}
		else
			{
			aFinished = ETrue;
			bytesToAdd = iSourceSize - iOffset;
			}

		aDes.Fill(fillChar, bytesToAdd);

		iOffset += bytesToAdd;
		}






	CABDataOwner* CABDataOwner::NewL()
		{
		CABDataOwner* self = new (ELeave) CABDataOwner;
		CleanupStack::PushL(self);
		self->ConstructL();
		CleanupStack::Pop(self);
		return self;
		}
			
	void CABDataOwner::StartL()
		{
		CActiveScheduler::Add(this);
		Subscribe();
		CActiveScheduler::Start();
		}

	void CABDataOwner::RunL()
		{
		if (iStatus == KErrNone)
			{
			__LOG1("[0x%08x]: ABTester RunL", iID.iId);				
			Subscribe();
			CheckStatusL();
			}
		else
			{
			__LOG2("[0x%08x]: RunL leaves with code %d", iID.iId, iStatus.Int());
			User::Leave(iStatus.Int());
			}
		}
		
	void CABDataOwner::Subscribe()
		{
		__LOG1("[0x%08x]: Subscibe", iID.iId);
		iProperty.Subscribe(iStatus);	// Wait until SBE tells us that we're in normal mode again
		SetActive();
		}
	
	TInt CABDataOwner::RunError(TInt aError)
		{
		__LOG2("ABDataOwner [0x%08x] Panic'd with error code %d", iID.iId, aError);
		
		Subscribe();
		
		return KErrNone;
		}
		
	void CABDataOwner::CheckStatusL()
		{
		TInt backupInfo =0;
		iProperty.Get(backupInfo);
		__LOG1("[0x%08x]: CABDataOwner::CheckStatus", iID.iId);
		if ((backupInfo & KBURPartTypeMask) == EBURNormal || (backupInfo & KBURPartTypeMask) == EBURUnset)
			{
			delete iABClient;
			iABClient = NULL;
			__LOG2("[0x%08x]: Backup Mode Normal or Unset, deleting client", iID.iId, backupInfo);
			}
		else 
			{
			if (iABClient == NULL)
				{
				iABClient = CActiveBackupClient::NewL(iCallback);
				iCallback->SetABClient(iABClient);
				// do nothing
				__LOG1("[0x%08x]: In Backup/Restore: ConfirmReadyForBUR", iID.iId);
				}
			
			TDriveList driveList;
			TBURPartType partType;
			TBackupIncType incType;
			TInt err;
			TRAP(err, iABClient->BURModeInfoL(driveList, partType, incType));
			if (err != KErrNone)
				{
				__LOG2("[0x%08x]: BURModeInfoL error %d", iID.iId, err);
				}
			
			TBool amIaffected = ETrue;
			
			if (partType == EBURRestorePartial || partType == EBURBackupPartial)
				{
				TRAP(err, amIaffected = iABClient->DoesPartialBURAffectMeL());
				if (err == KErrNone)
					{
					if (amIaffected)
						{
						__LOG1("[0x%08x]: RunL: Partial Affects me!", iID.iId);
						}
					else 
						{
						__LOG1("[0x%08x]: RunL: Partial Does NOT Affect me!", iID.iId);
						}
					}
				else 
					{
					__LOG2("[0x%08x]: Error calling DoesPartialBURAffectMeL()", iID.iId, err);
					
					User::After(5000000);
					TRAP(err, amIaffected = iABClient->DoesPartialBURAffectMeL());
					__LOG2("[0x%08x]: Called DoesPartialBURAffectMeL() again after 5sec: ", iID.iId, err);
					}
				}
			
			if (amIaffected)
				{
				// Confirm that this data owner is ready for backup/restore operations
				iABClient->ConfirmReadyForBURL(KErrNone);
				}
			}
		}

	void CABDataOwner::DoCancel()
		{
		}
		
	CABDataOwner::~CABDataOwner()
		{
		if (IsActive())
			{
			Cancel();
			}
		delete iCallback;
		delete iABClient;
		}

	void CABDataOwner::ConstructL()
		{
		RProcess process;
		iID = process.SecureId();
		process.Close();
		iABClient = NULL;
		
		iCallback = CABDataOwnerCallbackImplementation::NewL(iID);
		
		iProperty.Attach(TUid::Uid(KUidSystemCategoryValue), KUidBackupRestoreKey);
		TInt backupInfo = 0;
		iProperty.Get(backupInfo);
		if ((backupInfo & KBURPartTypeMask) != EBURNormal || (backupInfo & KBURPartTypeMask) != EBURUnset)
			{
			iABClient = CActiveBackupClient::NewL(iCallback);
			iCallback->SetABClient(iABClient);
				
			// Confirm that this data owner is ready for backup/restore operations
			iABClient->ConfirmReadyForBURL(KErrNone);
			// do nothing
			__LOG1("[0x%08x]: In Backup/Restore: ConfirmReadyForBUR", iID.iId);
			}
		__LOG1("[0x%08x]: ABTester ConstructL", iID.iId);
		}
	}
				
void RunActiveBackupClientL()
	{
    CActiveScheduler* pScheduler = new (ELeave) CActiveScheduler();
	CleanupStack::PushL(pScheduler);
	CActiveScheduler::Install(pScheduler);
	conn::CABDataOwner* pDO = conn::CABDataOwner::NewL();
	CleanupStack::PushL(pDO);

	pDO->StartL();
	
	CleanupStack::PopAndDestroy(pDO);
	CleanupStack::PopAndDestroy(pScheduler);
	}

TInt E32Main()
	{
	__UHEAP_MARK;
	CTrapCleanup* pCleanup = CTrapCleanup::New();
	TInt nRet = KErrNone;

	if(pCleanup != NULL)
		{
		TRAP(nRet, RunActiveBackupClientL());
	    delete pCleanup;
	    }

    __UHEAP_MARKEND;
    return nRet;	
	}