#include <e32std.h>

#include <e32test.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfldst.h>

#include <cntview.h>

#include "t_utils2.h"

#include <coreappstest/testserver.h>

#include "t_speeddialtest.h"

// Constants.

_LIT(KTestName,"T_SpeedDialTest");

// Configure database locations

_LIT(KDbFileName,"c:t_speeddialtest.cdb");

_LIT(KLongNumSpeedDialDbName, "c:LongNumSpeedDialDb.cdb");

// Configure .ini file location

_LIT(KContactsModelIniFile,"C:\\private\\10003A73\\CntModel.ini");

const TInt KNumSmsContacts=5;

const TInt KSpeedDialPositionOne = 1;

const TInt KSpeedDialPositionTwo  = 2;

const TInt KSpeedDialContact = 3;

const TInt KSpeedDialContactA = 4;

const TInt KSpeedDialContactB = 5;

// Global Data

RTest g_test( KTestName );

// Class CLockServerTester Implementation

CLockServerTester* CLockServerTester::NewL()

	{

	CLockServerTester* self=new(ELeave) CLockServerTester();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CLockServerTester::~CLockServerTester()

 	{

 	DeleteProcess();

 	}

CLockServerTester::CLockServerTester()

 	{

 	}

void CLockServerTester::ConstructL()

 	{

 	}

void CLockServerTester::FindServerAndKillItL()

 	{

 	SetupProcessL();

 	OpenAndKillProcess();

 	}

void CLockServerTester::OpenAndKillProcess()

	{

	iProcess.iExecution->Open(iProcessFullName);

	iProcess.iExecution->Kill(KErrNone);

	}

void CLockServerTester::SetupProcessL()

	{

	iProcess.iFind = new (ELeave) TFindProcess(_L("cntsrv*"));

	iProcess.iExecution = new (ELeave) RProcess();

	iProcess.iFind->Next(iProcessFullName);

	}

void CLockServerTester::DeleteProcess()

	{

	delete iProcess.iFind;

	if (iProcess.iExecution != NULL) iProcess.iExecution->Close();

	delete iProcess.iExecution;

	iProcess.iFind = NULL;

	iProcess.iExecution = NULL;

	}

// Function Implementation

TBool ContactIsASpeedDial(const CContactItem& aItem)

	{

	TBool retval = EFalse;

	CContactItemFieldSet& fields = aItem.CardFields();

	const TInt max = fields.Count();

	TInt counter = 0;

	for (counter = 0; counter < max; counter++)

		{

		retval = fields[counter].IsSpeedDial();

		if (retval) break;

		}

	return retval;

	}

TBool ContactIsASpeedDialL(TInt aContactId, CContactDatabase& aDatabase)

    {

    CContactItem* item = NULL;

    TBool result = EFalse;

    item = aDatabase.OpenContactL(aContactId);

    CleanupStack::PushL(item);

    const CContactItemFieldSet& fields = item->CardFields();

    const TInt count = fields.Count();

    for (TInt index = 0; index < count; ++index)

        {

        if (fields[index].IsSpeedDial())

            {

            result = ETrue;

            break;

            }

        }

    aDatabase.CloseContactL(aContactId);        

    CleanupStack::PopAndDestroy(item);        

    return result;    

    }

TInt DeleteIniFile()

	{

	TInt retval = KErrNone;

	//TInt deleteSuccess;

	// Delete any existing ini file so that we can be sure this test is ok

    RPIMTestServer serv;

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

    TRAPD (deleteSuccess, serv.DeleteFileL(KContactsModelIniFile));

    if ( deleteSuccess != KErrNotFound && deleteSuccess != KErrNone )

    {

		  retval = deleteSuccess;

	}

	return retval;

	}

void AddContactsL(CRandomContactGenerator& aGenerator)

	{

	TInt ii;

	for (ii=0;ii<KNumSmsContacts;ii++)

		{

		TInt bit=0;

		bit |= CContactDatabase::ESmsable;

		aGenerator.AddTypicalContactForFilterL(bit);

		}

	}

CContactDatabase* ReplaceDatabaseAndCreateContactsLC()

	{

	CContactDatabase* database = CContactDatabase::ReplaceL(KDbFileName);

	CleanupStack::PushL(database);

	CreateContactsL(*database);

	return database;

	}

void CreateContactsL(CContactDatabase& aDb)

	{

	CRandomContactGenerator* generator = CRandomContactGenerator::NewL();

	CleanupStack::PushL( generator );

	generator->SetDbL(aDb);

	AddContactsL(*generator);

	CleanupStack::PopAndDestroy( generator );

	}

CContactDatabase* SetupLC()

	{

	User::LeaveIfError( DeleteIniFile() );

	return ReplaceDatabaseAndCreateContactsLC();

	}

void AssignSpeedDialL( TInt aContact, TInt aSpeedDialID, CContactDatabase& database )

	{

	CContactItem* item = NULL;

	item = database.OpenContactL( aContact );

	CleanupStack::PushL( item );

	if ( ContactIsASpeedDial( *item ) )

		{

		g_test.Printf( _L("Contact is a speed dial !!! \n") );

		}

	else

		{

		g_test.Printf( _L("Contact is NOT A SPEED DIAL \n") );

		}

	CContactItemFieldSet &fieldSet = item->CardFields();

    for(TInt index = fieldSet.Count() - 1; index > 0; --index)

        {

        if(fieldSet[index].StorageType() == KStorageTypeText)

            {

            //set the last text field from the fieldset as speeddial field.

        	database.SetFieldAsSpeedDialL(*item, index, aSpeedDialID );

            break;

            }

        }

	g_test.Next( _L("Contact changed to speed dial") );

	g_test(ContactIsASpeedDial( *item ));

	CleanupStack::PopAndDestroy( item );

	}

void UpdateSpeedDialL(TInt aContact, TInt aSpeedDialID, CContactDatabase& database )

	{

	CContactItem* item = NULL;

	item = database.OpenContactL( aContact );

	CleanupStack::PushL( item );

	if ( ContactIsASpeedDial( *item ) )

		{

		g_test.Printf( _L("Contact is a speed dial !!! \n") );

		database.SetFieldAsSpeedDialL(*item, item->Id(), aSpeedDialID );

		}

	else

		{

		g_test.Printf( _L("Contact is NOT A SPEED DIAL \n") );

		}

	CleanupStack::PopAndDestroy( item );

	}

void RemoveSpeedDialL(TInt aContact, TInt aSpeedDialId, CContactDatabase& aDatabase)

    {    

    TInt error = KErrNone;

    TRAP(error, aDatabase.RemoveSpeedDialFieldL(aContact, aSpeedDialId));

    g_test(error == KErrNone);           

    }    

void RemoveSpeedDialWhenOpenL(TInt aContact, TInt aSpeedDialID, CContactDatabase& aDatabase)

	{

	CContactItem* card1 = 0;

	TInt error = KErrNone;

	// First open the contact, which locks it:

	card1 = aDatabase.OpenContactL(aContact);

	CleanupStack::PushL(card1);

	// Now attempt to open the contact (must fail with in use):

	error = KErrNone;

	TRAP(error, aDatabase.OpenContactL(aContact));

	g_test(error == KErrInUse);

	// Now remove the speed dial on that contact (must fail with in use):

	error = KErrNone;

	TRAP(error, aDatabase.RemoveSpeedDialFieldL(aContact, aSpeedDialID));

	g_test(error == KErrInUse);

	// Now remove the speed dial on that contact again (must fail with in use):

	// Defect was application crash.

	error = KErrNone;

	TRAP(error, aDatabase.RemoveSpeedDialFieldL(aContact, aSpeedDialID));

	g_test(error == KErrInUse);

	// Now attempt to open the contact (must fail with in use):

	// Defect was fails with wrong error/no error.

	error = KErrNone;

	TRAP(error, aDatabase.OpenContactL(aContact));

	g_test(error == KErrInUse);

	// Cleanup and close:

	CleanupStack::PopAndDestroy(card1);

	TRAP(error, aDatabase.CloseContactL(aContact));

	g_test(error == KErrNone);

	}

void TestDatabaseWithSpeedDialsL()

	{

	g_test.Next(_L("Setting up..."));

	CContactDatabase* database = SetupLC();

	g_test.Next(_L("First Speed dial assignment"));

	// Assign First time ok !

	TRAPD(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );

	g_test(error == KErrNone);

	g_test.Next(_L("Second Speed dial assignment"));

	// Assign Second time falls over !

	TRAP(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );

	g_test(error == KErrNone);

	g_test.Next(_L("Open contact, remove from speed dial, open again"));

	// The remove from speed dial on the open contact should return KErrInUse.

	// The second open should also return KErrInUse.

	TRAP(error, RemoveSpeedDialWhenOpenL(KSpeedDialContact, KSpeedDialPositionOne, *database));

	g_test(error == KErrNone);

	CleanupStack::PopAndDestroy( database );

	// wait until Contacts Lock Server shuts down

	User::After(6000000);

	g_test.Next( _L("Try to open db again"));

	database =  CContactDatabase::OpenL(KDbFileName);

	CleanupStack::PushL(database);

	CContactItem* item = database->ReadContactL(KSpeedDialContact);

	CleanupStack::PushL(item);

	g_test.Next( _L("Check that Speed dial is remembered"));

	g_test(item->Id() == KSpeedDialContact);

	// retored item should be a SpeedDial

	g_test(ContactIsASpeedDial( *item ));

	CleanupStack::PopAndDestroy(item);

	CleanupStack::PopAndDestroy(database);

	}

/**

@SYMTestCaseID PIM-T-SPEEDDIALTEST-0001

*/

void TestOneL()

	{

	g_test.Start(_L("@SYMTestCaseID:PIM-T-SPEEDDIALTEST-0001 Create Database with Speed Dials then Delete and Create database"));

	TestDatabaseWithSpeedDialsL();

	g_test.Next(_L("Delete database"));

	CContactDatabase::DeleteDatabaseL(KDbFileName);

	g_test.Next( _L("open database should fail"));

	CContactDatabase* database = NULL;

	TRAPD(openError, database =  CContactDatabase::OpenL(KDbFileName));

	g_test(openError == KErrNotFound && database == NULL);

	g_test.Next( _L("create replacement database"));

	database =  CContactDatabase::CreateL(KDbFileName);

	CleanupStack::PushL(database);

	CreateContactsL(*database);

	CContactItem* item = database->ReadContactL(KSpeedDialContact);

	CleanupStack::PushL(item);

	g_test.Next( _L("Check that Speed dial is forgotten"));

	g_test(item->Id() == KSpeedDialContact);

	// retored item should not be a SpeedDial

	g_test(!ContactIsASpeedDial( *item ));

	CleanupStack::PopAndDestroy(item);

	CleanupStack::PopAndDestroy(database);

	g_test.End();

	}

void TestTwoL()

	{

	g_test.Start(_L("Create Database with Speed Dials then Replace database"));

	TestDatabaseWithSpeedDialsL();

	g_test.Next(_L("Replace database"));

	CContactDatabase* database = ReplaceDatabaseAndCreateContactsLC();

	CContactItem* item = database->ReadContactL(KSpeedDialContact );	

	CleanupStack::PushL(item);

	g_test.Next(_L("Check that Speed dial is forgotten"));

	g_test(item->Id() == KSpeedDialContact);

	// retored item should not be a SpeedDial

	g_test(!ContactIsASpeedDial( *item ));

	CleanupStack::PopAndDestroy(item);

	CleanupStack::PopAndDestroy(database);

	g_test.End();

	}

void TestThreeL()

	{

	g_test.Start(_L("Check that Settings are saved - normal shutdown"));

    g_test.Next(_L("Setting up..."));

	CContactDatabase* database = SetupLC();

	g_test.Next( _L("Assign Speed Dial"));

	TInt error = KErrNone;

	TRAP(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );

	g_test(error == KErrNone);

	g_test.Next( _L("Update Speed Dial"));

	error = KErrNone;

	TRAP(error, UpdateSpeedDialL( KSpeedDialContact, KSpeedDialPositionTwo, *database ) );

	g_test(error == KErrNone);

	g_test.Next( _L("Change Database Drive"));

	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveD),EFalse);

	CleanupStack::PopAndDestroy( database );

	g_test.Next(_L("Wait for Contact Server to shutdown"));

	// wait until Contacts Lock Server shuts down

	// applicabale only in the case of transient server.

	User::After(6000000);

	g_test.Next( _L("Try to open Database again"));

	database =  CContactDatabase::OpenL(KDbFileName);

	CleanupStack::PushL(database);

	TDriveUnit driveUnit;

	CContactDatabase::DatabaseDrive(driveUnit);

	g_test.Next( _L("Check that Database Drive is changed"));

	g_test(driveUnit==TDriveUnit(EDriveD));

	CContactItem* item = database->ReadContactL(KSpeedDialContact);

	CleanupStack::PushL(item);

	g_test.Next( _L("Check that Speed Dial is remembered"));

	g_test(item->Id() == KSpeedDialContact);

	// retored item should be a SpeedDial

	g_test(ContactIsASpeedDial( *item ));

	// reset Database Drive

	g_test.Next( _L("Reset Database Drive setting"));

	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);

	CleanupStack::PopAndDestroy(item);

	CleanupStack::PopAndDestroy(database);

	g_test.End();

	}

void TestFourL()

	{

	g_test.Start(_L("Check that Settings are saved - killing ContactLockSrv"));

    g_test.Next(_L("Setting up..."));

	CLockServerTester* lockSrvTester = CLockServerTester::NewL();

	CleanupStack::PushL(lockSrvTester);

	CContactDatabase* database = SetupLC();

	g_test.Next( _L("Assign Speed Dial"));

	TInt error = KErrNone;

	TRAP(error, AssignSpeedDialL( KSpeedDialContact, KSpeedDialPositionOne, *database ) );

	g_test(error == KErrNone);

	g_test.Next( _L("Update Speed Dial"));

	error = KErrNone;

	TRAP(error, UpdateSpeedDialL( KSpeedDialContact, KSpeedDialPositionTwo, *database ) );

	g_test(error == KErrNone);

	g_test.Next( _L("Change Database Drive"));

	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveD),EFalse);

	CleanupStack::PopAndDestroy(database);

	// Kill ContactLockServer process

	g_test.Next( _L("Kill CntServer"));

	lockSrvTester->FindServerAndKillItL();

	CleanupStack::PopAndDestroy( lockSrvTester );

	g_test.Next( _L("Open Database"));

	database =  CContactDatabase::OpenL(KDbFileName);

	CleanupStack::PushL(database);

	TDriveUnit driveUnit;

	CContactDatabase::DatabaseDrive(driveUnit);

	g_test.Next( _L("Check that Database Drive is changed"));

	g_test(driveUnit==TDriveUnit(EDriveD));

	CContactItem* item = database->ReadContactL(KSpeedDialContact);

	CleanupStack::PushL(item);

	g_test.Next( _L("Check that Speed Dial is remembered"));

	g_test(item->Id() == KSpeedDialContact);

	// retored item should be a SpeedDial

	g_test(ContactIsASpeedDial( *item ));

	// reset Database Drive

	g_test.Next( _L("Reset Database Drive setting"));

	CContactDatabase::SetDatabaseDriveL(TDriveUnit(EDriveC),EFalse);

	CleanupStack::PopAndDestroy(item);

	CleanupStack::PopAndDestroy(database);

	g_test.End();