/*
* Copyright (c) 2007 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:  Utility class to store settings for predictive search.
*                Used to set the desired data stores to search and 
*                the display fields for predictive search.
*
*/


// INCLUDE FILES
#include <s32mem.h>
#include "CPsSettings.h"

// ============================== MEMBER FUNCTIONS ============================


// ----------------------------------------------------------------------------
// CPsSettings::NewL
// Two Phase constructor
// ----------------------------------------------------------------------------
EXPORT_C CPsSettings* CPsSettings::NewL()
{
	CPsSettings* self = new (ELeave) CPsSettings();	
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
}

// ----------------------------------------------------------------------------
// CPsSettings::CPsSettings
// Default constructor
// ----------------------------------------------------------------------------
CPsSettings::CPsSettings()
{
}

// ----------------------------------------------------------------------------
// CPsSettings::ConstructL
// Two phase construction
// ----------------------------------------------------------------------------
void CPsSettings::ConstructL()
{
   iMaxResults = -1;
   iSortType = EAlphabetical;
}


// ----------------------------------------------------------------------------
// CPsSettings::CloneL
// Returns the clone.
// ------------------------------------------------------------------------
EXPORT_C CPsSettings*  CPsSettings::CloneL() const
{
    CPsSettings* self = CPsSettings::NewL();	
    CleanupStack::PushL(self);
    // Set the Max reslts
	self->SetMaxResults(iMaxResults);
	self->SetSortType(iSortType);
    
    // Copy the search uris
    RPointerArray<TDesC> newUris;

    for(TInt i =0; i < iSearchUri.Count() ; i++)
	{
		newUris.Append(iSearchUri[i]->AllocL());
	}
    self->SetSearchUrisL(newUris);
    self->SetSearchUrisL(iSearchUri);
    
    // Set the display fields
    self->SetDisplayFieldsL(iDisplayFields);
     
    newUris.ResetAndDestroy();
    
    CleanupStack::Pop();
    return self;
}

// ----------------------------------------------------------------------------
// CPsSettings::~CPsSettings
// Destructor
// ----------------------------------------------------------------------------
EXPORT_C CPsSettings::~CPsSettings()
{
	iSearchUri.ResetAndDestroy();
	iDisplayFields.Reset();
}

// ----------------------------------------------------------------------------
// CPsSettings::SetSearchUrisL
// Sets the list of URIs to search from.
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::SetSearchUrisL(const RPointerArray<TDesC>& aSearchUri)
{   
	iSearchUri.ResetAndDestroy();
    for(TInt i =0 ; i < aSearchUri.Count();i++)
	{
		const HBufC* uriToAppend = aSearchUri[i]->AllocL();
		iSearchUri.Append(uriToAppend);
	}
}

// ----------------------------------------------------------------------------
// CPsSettings::SetDisplayFieldsL
// Sets the list of fields to display.
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::SetDisplayFieldsL(const RArray<TInt>& aDisplayFields)
{
	iDisplayFields.Reset();
    for(TInt i =0 ; i < aDisplayFields.Count();i++)
	{
		iDisplayFields.Append(aDisplayFields[i]);
	}
}

// ----------------------------------------------------------------------------
// CPsSettings::SetMaxResults
// Sets the number of elements (contacts) to be given to client.
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::SetMaxResults(const TInt aMaxResults)
{
	if(aMaxResults >= -1)
	{
		iMaxResults = aMaxResults;
	}
	else
	{
		iMaxResults = -1;
	}	
}

// ----------------------------------------------------------------------------
// CPsSettings::SetSortType
// Sets the sort type for the search
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::SetSortType(const TSortType aSortType)
{
	iSortType = aSortType;
}

// CPsSettings::SearchUrisL
// Returns the list of URIs configured to search from.
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings:: SearchUrisL(RPointerArray<TDesC>& aSearchUri) const
{
    //Cleanup already existing memory
    for(TInt i =0 ; i < iSearchUri.Count();i++)
	{
		const HBufC* uriToAppend =iSearchUri[i]->AllocL();
		aSearchUri.Append(uriToAppend);
	}
}

// ----------------------------------------------------------------------------
// CPsSettings::DisplayFieldsL
// Returns the list of fields to display.
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings:: DisplayFieldsL(RArray<TInt>& aDisplayFields) const
{
    for(TInt i =0 ; i < iDisplayFields.Count();i++)
	{
		aDisplayFields.Append(iDisplayFields[i]);
	}
}

// ----------------------------------------------------------------------------
// CPsSettings::MaxResults
// Returns the number of elements (contacts) to be given to client.
// ----------------------------------------------------------------------------
EXPORT_C TInt CPsSettings::MaxResults() const
{
	return iMaxResults;
}

// ----------------------------------------------------------------------------
// CPsSettings::GetSortType
// Returns the sort type based on which results will be sorted.
// ----------------------------------------------------------------------------
EXPORT_C TSortType CPsSettings::GetSortType() const
{
	return iSortType;
}

// ----------------------------------------------------------------------------
// CPsSettings::GetGroupIdsL
// Returns the array  groupId from the URIs specified in the settings
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::GetGroupIdsL(RArray<TInt>& aGroupIdArray) 
{
    aGroupIdArray.Reset();
    
    // The format for groups URI is "cntdb:://group.gdb/group?=<groupId>"
    // We use "=" to identify if it is  a group URI
    TChar equalToCharacter('=');
    
    // Parse through all the URIs
    for ( TInt i =0; i < iSearchUri.Count(); i++ ) 
    {	    	
    	TInt offset = iSearchUri[i]->Locate(equalToCharacter);
		
		if ( offset != KErrNotFound )
		{
			// Parse and Extract the group name
			TInt len = iSearchUri[i]->Length();
			HBufC* grpIdBuf = iSearchUri[i]->Right(len - offset - 1).AllocL();

			// Convert to decimal 
			TInt grpIdVal = 0;
			TLex16 myDocId(*grpIdBuf);
			TInt err = myDocId.Val(grpIdVal);
			 	
			// Append to aGroupIdArray, if conversion is successful
			if( KErrNone == err)
			{
				aGroupIdArray.Append(grpIdVal);
			}
				   
			// Cleanup memory
			delete   grpIdBuf;
			grpIdBuf = NULL;
		}
	}		
}

// ----------------------------------------------------------------------------
// CPsSettings::ExternalizeL
// Writes 'this' to aStream
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::ExternalizeL(RWriteStream& aStream) const
{     
    aStream.WriteUint8L(iSearchUri.Count()); // Number of databse URIs

	for ( int index = 0; index < iSearchUri.Count(); index++ )
	{
	    HBufC* uri = iSearchUri[index]->AllocL();
	    if ( uri ) // Write uri to the stream (or a NULL descriptor)
	    {
	    	aStream.WriteUint8L( uri->Size() ); // uri size
			aStream << *uri; // uri
	    }
	    else
	    {
	    	aStream.WriteUint8L( 0 );
	    	aStream << KNullDesC8;
	    }
	    delete uri;
	    uri = NULL;	    	
	}
	
    aStream.WriteUint8L(iDisplayFields.Count()); // Number of display fields
	for ( int index = 0; index < iDisplayFields.Count(); index++ )
	{
		aStream.WriteInt16L(iDisplayFields[index]);
	}

    aStream.WriteInt16L(iMaxResults); // Number of contacts that will be displayed to the client
    aStream.WriteInt8L(iSortType); // Set the sort type
}

// ----------------------------------------------------------------------------
// CPsSettings::InternalizeL
// Initializes 'this' with the contents of aStream
// ----------------------------------------------------------------------------
EXPORT_C void CPsSettings::InternalizeL(RReadStream& aStream)
{
    // Read number of database URIs
    TInt szNumUri = aStream.ReadUint8L();
    
    for ( int index = 0; index < szNumUri; index++ )
    {
        // Read uri size
	    TUint8 szUri = aStream.ReadUint8L();
    	    
    	HBufC* uri =  HBufC::NewL(aStream, szUri);
	    iSearchUri.InsertL(uri, index);   
    }
    
    // Read number of display fields
    TInt szNumFields = aStream.ReadUint8L();
    for ( int index = 0; index < szNumFields; index++ )
    {
    	iDisplayFields.InsertL(aStream.ReadInt16L(), index);
    }
    
    // Read Number of contacts that will be displayed to the client
    iMaxResults = aStream.ReadInt16L();
    iSortType = (TSortType)aStream.ReadInt8L();
}