/*
* Copyright (c) 2010 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 FILES
#include <e32svr.h>
#include <S32MEM.H>

#include "SearchClient.pan"
#include "CCPixIndexer.h"
#include "MCPixIndexerObserver.h"
#include "SearchServerCommon.h"
#include "CSearchDocument.h"

// CCPixIndexer::NewL()
// Two-phased constructor.
EXPORT_C CCPixIndexer* CCPixIndexer::NewL(RSearchServerSession& aSearchServerSession)
	{
	CCPixIndexer* self = NewLC(aSearchServerSession);
	CleanupStack::Pop( self );
	return self;
	}

// CCPixIndexer::NewLC()
// Two-phased constructor.
EXPORT_C CCPixIndexer* CCPixIndexer::NewLC(RSearchServerSession& aSearchServerSession)
	{
	CCPixIndexer* self = new ( ELeave ) CCPixIndexer(aSearchServerSession);
	CleanupStack::PushL( self );
	self->ConstructL();
	return self;
	}

// CCPixIndexer::ConstructL()
// Symbian 2nd phase constructor can leave.
void CCPixIndexer::ConstructL()
	{
	User::LeaveIfError( iSubSession.Open(iSearchServerSession) );
	}

// CCPixIndexer::CCPixIndexer()
// C++ default constructor can NOT contain any code, that might leave.
CCPixIndexer::CCPixIndexer(RSearchServerSession& aSearchServerSession)
	: CActive( CActive::EPriorityStandard ),
	  iSearchServerSession(aSearchServerSession),
	  iState( EStateNone )
	{
	CActiveScheduler::Add( this );
	}

// CCPixIndexer::~CCPixIndexer()
// Destructor.
EXPORT_C CCPixIndexer::~CCPixIndexer()
	{
	Cancel(); // releases temporary values used in requests
	iSubSession.Close();
	
	delete iSerializedDocument;
	delete iBaseAppClass;
	delete iAnalyzer;
	delete iDocUidToDelete;
	}
 
// Helper function to serialize a document
void CCPixIndexer::SerializeDocumentL(const CSearchDocument& aDocument)
	{
	if (iSerializedDocument)
		{
		delete iSerializedDocument;
		iSerializedDocument = NULL;
		}
	iSerializedDocument = HBufC8::NewL(aDocument.Size());
	TPtr8 ptr = iSerializedDocument->Des();
	
	// Initialize a new stream
	RDesWriteStream stream;
	stream.Open(ptr);
	stream.PushL();

	// Externalize hits to the stream
	aDocument.ExternalizeL(stream);

	// Commit and destroy the stream
	stream.CommitL();
	CleanupStack::PopAndDestroy(&stream);	
	}

EXPORT_C TBool CCPixIndexer::IsDatabaseOpen() const
	{
	return iIsDatabaseOpen; 
	}

EXPORT_C const TDesC& CCPixIndexer::GetBaseAppClass() const
{
	if (iBaseAppClass)
		return *iBaseAppClass;
	else
		return KNullDesC;
}

EXPORT_C void CCPixIndexer::OpenDatabaseL(const TDesC& aBaseAppClass )
	{
	if (IsActive())
		{
		User::Leave(KErrInUse);
		}
	iIsDatabaseOpen = EFalse; // If opening database fails, this is the safe assumption
	delete iBaseAppClass; 
	iBaseAppClass = NULL; 
	iBaseAppClass = aBaseAppClass.AllocL(); 
	iSubSession.OpenDatabaseL(EFalse, *iBaseAppClass, KNullDesC); // Create if not found
	iIsDatabaseOpen = ETrue;
	}

EXPORT_C void CCPixIndexer::OpenDatabaseL(MCPixOpenDatabaseRequestObserver& aObserver, const TDesC& aBaseAppClass )
	{
	if (IsActive())
		User::Leave(KErrInUse);
	
	delete iBaseAppClass;
	iBaseAppClass = NULL; 
	iBaseAppClass = aBaseAppClass.AllocL(); 
	iIsDatabaseOpen = EFalse; // If opening database fails, this is the safe assumption

	iRequestObserver.iOpenDatabase = &aObserver;
	iState = EStateOpenDatabase;
	iSubSession.OpenDatabase(EFalse, *iBaseAppClass, KNullDesC, iStatus); // Create if not found
	SetActive();
	}

EXPORT_C void CCPixIndexer::SetAnalyzerL( const TDesC& aAnalyzer )
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);

	iSubSession.SetAnalyzerL( aAnalyzer ); 
	}

EXPORT_C void CCPixIndexer::SetAnalyzerL( MCPixSetAnalyzerRequestObserver& aObserver, const TDesC& aAnalyzer )
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);
	
	iAnalyzer = aAnalyzer.AllocL(); 

	iRequestObserver.iSetAnalyzer = &aObserver;
	iState = EStateSetAnalyzer; 
	iSubSession.SetAnalyzer( aAnalyzer, iStatus );
	SetActive(); 
	}


EXPORT_C void CCPixIndexer::AddL(const CSearchDocument& aDocument)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);
	
	SerializeDocumentL(aDocument);
	
	iSubSession.AddL(*iSerializedDocument);
	}

EXPORT_C void CCPixIndexer::AddL(MCPixIndexingRequestObserver& aObserver, const CSearchDocument& aDocument)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);
	
	SerializeDocumentL(aDocument);
	
	iRequestObserver.iIndexing = &aObserver;
	iState = EStateAdd;	
	iSubSession.Add(*iSerializedDocument, iStatus);
	SetActive();
	}

EXPORT_C void CCPixIndexer::UpdateL(const CSearchDocument& aDocument)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);

	SerializeDocumentL(aDocument);
	iSubSession.UpdateL(*iSerializedDocument);
	}

EXPORT_C void CCPixIndexer::UpdateL(MCPixIndexingRequestObserver& aObserver, const CSearchDocument& aDocument)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);
		
	SerializeDocumentL(aDocument);
	
	iRequestObserver.iIndexing = &aObserver;
	iState = EStateUpdate;
	iSubSession.Update(*iSerializedDocument, iStatus);
	SetActive();
	}

EXPORT_C void CCPixIndexer::DeleteL(const TDesC& aDocUid)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);
	
	iSubSession.DeleteL(aDocUid);
	}

EXPORT_C void CCPixIndexer::DeleteL(MCPixIndexingRequestObserver& aObserver, const TDesC& aDocUid)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);

	delete iDocUidToDelete;
	iDocUidToDelete = NULL;

	iDocUidToDelete = aDocUid.AllocL();

	iRequestObserver.iIndexing = &aObserver;
	iState = EStateDelete;
	iSubSession.Delete(*iDocUidToDelete, iStatus);
	SetActive();
	}


EXPORT_C void CCPixIndexer::ResetL()
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);

	iSubSession.ResetL();
	}

EXPORT_C void CCPixIndexer::ResetL(MCPixIndexingRequestObserver& aObserver)
	{
	if ( !iIsDatabaseOpen ) 	User::Leave(KErrNotReady);
	if ( IsActive() ) 			User::Leave(KErrInUse);

	iRequestObserver.iIndexing = &aObserver;
	iState = EStateReset;
	iSubSession.Reset(iStatus);
	SetActive();
	}

EXPORT_C void CCPixIndexer::FlushL()
    {
    if ( !iIsDatabaseOpen )     User::Leave(KErrNotReady);
    if ( IsActive() )           User::Leave(KErrInUse);
    
    iSubSession.FlushL();
    }

EXPORT_C void CCPixIndexer::FlushL(MCPixIndexingRequestObserver& aObserver)
    {
    if ( !iIsDatabaseOpen )     User::Leave(KErrNotReady);
    if ( IsActive() )           User::Leave(KErrInUse);
    
    iRequestObserver.iIndexing = &aObserver;
    iState = EStateFlush; 
    iSubSession.Flush(iStatus);
    SetActive();
    }

// CCPixIndexer::RunL()
// Invoked to handle responses from the server.
void CCPixIndexer::RunL()
	{
	TState oldState = iState;
	iState = EStateNone; 
	
	TRequestObserver observer = iRequestObserver; 
	iRequestObserver.iAny = NULL;
	
	if (iSerializedDocument)
		{
		delete iSerializedDocument;
		iSerializedDocument = NULL;
		}

	switch (oldState) 
		{
		case EStateOpenDatabase: 
			iIsDatabaseOpen = (iStatus.Int() == KErrNone);
			if ( observer.iOpenDatabase ) 
				observer.iOpenDatabase->HandleOpenDatabaseResultL(iStatus.Int());
			break;
		case EStateSetAnalyzer:
			delete iAnalyzer; iAnalyzer = NULL; 
			if ( observer.iSetAnalyzer ) 
				observer.iSetAnalyzer->HandleSetAnalyzerResultL(iStatus.Int());
			break;
		case EStateDelete: 
			delete iDocUidToDelete;
			iDocUidToDelete = NULL;
			// fallthrough
		case EStateAdd: 		// fallthrough
		case EStateUpdate: 		// fallthrough
		case EStateReset:
		case EStateFlush:
			if ( observer.iIndexing ) 
				observer.iIndexing->HandleIndexingResultL(iStatus.Int());
			break;
		}

	}

// CCPixIndexer::DoCancel()
// Cancels any outstanding operation.
void CCPixIndexer::DoCancel()
	{
	iSubSession.CancelAll();
	}

TInt CCPixIndexer::RunError(TInt /* aError */)
	{
	return KErrNone; // Don't panic
	}

// End of File