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

// Internal class for opening and manipulating the bookmark database.

// @internalComponent

// 

//

#include <e32test.h>

#include "bkmrk.h"

#include "bkmrkfolder.h"

#include "bkmrkdb.h"

#include "repository.h"

_LIT8(KEmptyIconData, "");

const TInt KVersionMajor = 1;

const TInt KVersionMinor = 0;

const TInt KVersionBuild = 1;

const TInt 	KFirstIndex	= 1;

CBookmarkDb* CBookmarkDb::NewL(Bookmark::TVisibility aVisibility, MBookmarkObserver* aObserver)

	{

	CBookmarkDb* self = new (ELeave) CBookmarkDb(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL(aVisibility);

	CleanupStack::Pop(self);

	return self;

	}

CBookmarkDb::~CBookmarkDb()

	{

	delete iHomeText;

	delete iSearchUri;

	delete iDatabaseWatcher;

	delete iDatabaseRepository;

	delete iFolderWatcher;

	delete iFolderRepository;

	delete iBookmarkWatcher;

	delete iBookmarkRepository;

	delete iIconWatcher;

	delete iIconRepository;

	Reset();

	delete iCustomProperties;

	delete iPropertyRegister;

	delete iUnloadedFolderList;

	}

CBookmarkDb::CBookmarkDb(MBookmarkObserver* aObserver)

	: iObserver(aObserver)

	{

	}

void CBookmarkDb::ConstructL(Bookmark::TVisibility aVisibility)

	{

	RThread thread;

	TSecurityInfo secInfo(thread);

	TBool hasWriteUserData = secInfo.iCaps.HasCapability(ECapabilityWriteUserData);

	if (aVisibility == Bookmark::EVisibilityManager && !hasWriteUserData)

		{

		User::Leave(KErrPermissionDenied);

		}

	iVisibility = (aVisibility == Bookmark::EVisibilityDefault) ? Bookmark::EVisibilityAll : aVisibility;

	iDatabaseRepository = CRepository::NewL(KUidBookmarkDatabaseRepository);

	SetRepository(*iDatabaseRepository);

	iFolderRepository = CRepository::NewL(KUidFolderRepository);

	iBookmarkRepository = CRepository::NewL(KUidBookmarkRepository);

	iIconRepository = CRepository::NewL(KUidIconRepository);

	iPropertyRegister = CPropertyReg::NewL();

	iCustomProperties = CPropertyList::NewL(*iDatabaseRepository, *iPropertyRegister, CPropertyReg::EGroupDatabase, KDbCusPropertyStart);

	// Create the repositories if they don't exist

	TPckgBuf<TVersion> pckg;

	TInt err = iDatabaseRepository->Get(KVersionIndex, pckg);

	if (err == KErrNone)

		{

		TransactionL(ETransLoad);

		iBkmrkDbInitialized = ETrue;

		}

	else if (err == KErrNotFound)

		{

		// Set all as default empty values

		iHomeId 		= Bookmark::KNullItemID;

		iHomeText 		= KNullDesC().AllocL();

		iSearchUri 		= KNullDesC8().AllocL();

		iDefaultProxy 	= 0;

		iDefaultNap 	= 0;

		}

	else

		{

		User::Leave(err);

		}

	if (iObserver)

		{

		iDatabaseWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherDatabase, *this, *iDatabaseRepository);

		iDatabaseWatcher->WatchL();

		iFolderWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherFolder, *this, *iFolderRepository);

		iFolderWatcher->WatchL();

		iBookmarkWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherBookmark, *this, *iBookmarkRepository);

		iBookmarkWatcher->WatchL();

		iIconWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherIcon, *this, *iIconRepository);

		iIconWatcher->WatchL();

		}

	iTreeSync = EFalse;

	iConfigSync = EFalse;

	iIconSync = EFalse;

	iUnloadedFolderList = new (ELeave) CDesCArrayFlat(10);

	SetClean();

	}

void CBookmarkDb::Reset()

	{

	ResetTree();

	ResetIcons();

	if (iCustomProperties)

		{

		iCustomProperties->Reset();

		}

	}

void CBookmarkDb::ResetTree()

	{

	if (iRoot)

		{

		iRoot->Reset();

		delete iRoot;

		iRoot = NULL;

		iTreeConstructed = EFalse;

		}

	if (iUnloadedFolderList)

		{

		iUnloadedFolderList->Reset();

		}

	iFolderList.Reset();

	iBookmarkList.Reset();

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

		{

		delete iDeletedList[index];

		}

	iDeletedList.Reset();

	}

void CBookmarkDb::ResetIcons()

	{

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

		{

		delete iIconList[index];

		}

	iIconList.Reset();

	iIconSync = EFalse;

	}

void CBookmarkDb::RefreshL()

	{

	// If no repository files( no bookmark data ) exists, it is not required to

	// refresh the bookmark view. Check whether the repository has data or not

	// 

	if ( HasDataInRepositoryL () )

		{

		TransactionL(ETransLoad);

		ResetTree();

		ConstructTreeL();

		ResetIcons();

		LoadIconsL();				

		}		

	}

void CBookmarkDb::InitialiseRepL(CRepository& aRepository)

	{

	TPckgBuf<TVersion> pckg;

	TInt err = aRepository.Get(KVersionIndex, pckg);

	if (err == KErrNotFound)

		{

		TInt result = KErrLocked;

		do

			{

			aRepository.StartTransaction(CRepository::EConcurrentReadWriteTransaction);

			// create entries in the repository

			TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);

			TPckgBuf<TVersion> pckg(version);

			aRepository.Create(KVersionIndex, pckg);

			aRepository.Create(KRepNextIndex, KFirstIndex);

			// commit the transaction

			TUint32 failedIndex;

			result = aRepository.CommitTransaction(failedIndex);

			} while (result == KErrLocked);

		User::LeaveIfError(result);

		}

	else if (err != KErrNone)

		{

		User::Leave(err);

		}

	}

void CBookmarkDb::CommitL()

	{

	CreateDefaultRepositoriesL ();

	CRepositoryAccessor::CommitL();

	iPropertyRegister->CommitL();

	iCustomProperties->CommitL();

	TInt index = iFolderList.Count() - 1;

	for (;index >= 0; --index)

		{

		iFolderList[index]->CommitL();

		}

	index = iBookmarkList.Count() - 1;

	for (;index >= 0; --index)

		{

		iBookmarkList[index]->CommitL();

		}

	index = iIconList.Count() - 1;

	for (;index >= 0; --index)

		{

		iIconList[index]->CommitL();

		}

	index = iDeletedList.Count() - 1;

	for (;index >= 0; --index)

		{

		iDeletedList[index]->CommitL();

		delete iDeletedList[index];

		iDeletedList[index] = NULL;

		}

	iDeletedList.Reset();

	}

CBookmarkFolder& CBookmarkDb::RootL()

	{

	ConstructTreeL();

	return *iRoot;

	}

CBookmarkFolder* CBookmarkDb::FindFolder(const TDesC& aFolderName)

	{

	TInt index = iFolderList.Count() - 1;

	for (;index >=0; --index)

		{

		if (iFolderList[index] != NULL &&

			aFolderName.Compare(iFolderList[index]->Title()) == 0)

			{

			return static_cast<CBookmarkFolder*>(iFolderList[index]);

			}

		}

	return NULL;

	}

CBookmark& CBookmarkDb::CreateBookmarkL(CBookmarkFolder& aParent)

	{

	CreateDefaultRepositoriesL ();

	ConstructTreeL();

	CBookmarkFolder* parent = &aParent;

	CBookmark* bookmark = CBookmark::NewL(*parent, *this);

	CleanupStack::PushL(bookmark);

	bookmark->AssignIdL();

	bookmark->SetTitleL(KNullDesC);

	iBookmarkList.AppendL(bookmark);

	CleanupStack::Pop(bookmark);

	return *bookmark;

	}

CBookmarkFolder& CBookmarkDb::CreateFolderL(const TDesC& aFolderName, CBookmarkFolder& aParent)

	{

	CreateDefaultRepositoriesL ();

	if (FindFolder(aFolderName) || FindUnloadedFolder(aFolderName))

		{

		User::Leave(Bookmark::KErrTitleAlreadyUsed);

		}

	ConstructTreeL();

	CBookmarkFolder* parent = &aParent;

	CBookmarkFolder* folder = CBookmarkFolder::NewL(parent, *this);

	CleanupStack::PushL(folder);

	folder->AssignIdL();

	folder->SetTitleL(aFolderName);

	iFolderList.AppendL(folder);

	CleanupStack::Pop(folder);

	return *folder;

	}

void CBookmarkDb::DeleteItemL(Bookmark::TItemId aItem, TBool aRecursive)

	{

	if (aItem == Bookmark::KRootItemID)

		{

		User::Leave(Bookmark::KErrOperationDenied);

		}

	CBookmarkBase* item = FindItem(aItem);

	if (!item)

		{

		User::Leave(KErrNotFound);

		}

  	if (item->Type() == Bookmark::ETypeFolder && !aRecursive)

		{

		CBookmarkFolder* folder = static_cast<CBookmarkFolder*>(item);

		folder->SendChildrenToFolderL(*iRoot);

		}

	// Bookmark items are not deleted until the database is commited

	// Deleted items are removed from the folder tree and go into a

	// 'deleted' list. On a commit the deleted list is deleted from memory

	// and from the repository.

  	item->DeleteL();

	}

void CBookmarkDb::RemoveBookmarkL(CBookmark* aBookmark)

	{

	TInt index = iBookmarkList.Find(aBookmark);

	if (index != KErrNotFound)

		{

		if (Home() == aBookmark)

			{

			SetHome(NULL);

			}

		iBookmarkList.Remove(index);

		iDeletedList.AppendL(aBookmark);

		}

	}

void CBookmarkDb::RemoveFolderL(CBookmarkFolder* aFolder)

	{

	TInt index = iFolderList.Find(aFolder);

	if (index != KErrNotFound)

		{

		iFolderList.Remove(index);

		iDeletedList.AppendL(aFolder);

		}

	}

const TDesC8& CBookmarkDb::IconL(Bookmark::TAttachmentId aIconId)

	{

	LoadIconsL();

	TInt index = FindIcon(aIconId);

	if (index == KErrNotFound)

		{

		User::Leave(KErrNotFound);

		}

	return iIconList[index]->Data();

	}

Bookmark::TAttachmentId CBookmarkDb::CreateIconL(const TDesC8& aData)

	{

	CreateDefaultRepositoriesL ();

	LoadIconsL();

	CBkmrkAttachment* icon = CBkmrkAttachment::NewL(*iIconRepository, aData);

	CleanupStack::PushL(icon);

	icon->SetIdL();

	iIconList.AppendL(icon);

	CleanupStack::Pop(icon);

	return icon->Id();

	}

TInt CBookmarkDb::DeleteIconL(Bookmark::TAttachmentId aIconId)

	{

	LoadIconsL();

	TInt index = FindIcon(aIconId);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	iDeletedList.AppendL(iIconList[index]);

	iIconList[index]->DeleteL();

	iIconList.Remove(index);

	return KErrNone;

	}

TVersion CBookmarkDb::Version()

	{

	TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);

	return version;

	}

Bookmark::TVisibility CBookmarkDb::Visibility()

	{

	return iVisibility;

	}

void CBookmarkDb::SetHome(CBookmark* aHome)

	{

	iHome = aHome;

	if (iHome)

		{

		iHomeId = iHome->Id();

		}

	else

		{

		iHomeId = Bookmark::KNullItemID;

		}

	SetDirty();

	}

CBookmark* CBookmarkDb::Home()

	{

	return iHome;

	}

const TDesC& CBookmarkDb::HomePageText() const

	{

	return *iHomeText;

	}

void CBookmarkDb::SetHomePageTextL(const TDesC& aHomePageText)

	{

	// The aHomePageText must be smaller that the maximim descriptor storage size

	__ASSERT_ALWAYS(aHomePageText.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));

	delete iHomeText;

	iHomeText = NULL;

	iHomeText = aHomePageText.AllocL();

	SetDirty();

	}

const TDesC8& CBookmarkDb::SearchUri() const

	{

	return *iSearchUri;

	}

void CBookmarkDb::SetSearchUriL(const TDesC8& aUri)

	{

	// The aUri must be smaller that the maximim uri storage size

	__ASSERT_ALWAYS(aUri.Length() <= Bookmark::KMaxUriLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));

	delete iSearchUri;

	iSearchUri = NULL;

	iSearchUri = aUri.AllocL();

	SetDirty();

	}

TUint32 CBookmarkDb::DefaultProxy() const

	{

	return iDefaultProxy;

	}

void CBookmarkDb::SetDefaultProxy(TUint32 aServiceId)

	{

	iDefaultProxy = aServiceId;

	SetDirty();

	}

TUint32 CBookmarkDb::DefaultNap() const

	{

	return iDefaultNap;

	}

void CBookmarkDb::SetDefaultNap(TUint32 aNetworkId)

	{

	iDefaultNap = aNetworkId;

	SetDirty();

	}

TBool CBookmarkDb::IsTreeConstructed()

	{

	return (iRoot != NULL && iTreeConstructed);

	}

void CBookmarkDb::ConstructTreeL()

	{

	if (!iRoot)

		{

		iRoot = CBookmarkFolder::NewL(NULL, *this);

		iRoot->SetTitleL(Bookmark::KTxtRootTitle);

		iRoot->SetId(Bookmark::KRootItemID);

		}

	if ( !IsTreeConstructed() && HasDataInRepositoryL () )

		{

		// Load the tree only if the bookmark db is initialized

		// and the tree is not already constructed.

		LoadTreeL ();			

 		}

	}

CBookmarkBase* CBookmarkDb::FindItem(Bookmark::TItemId aItemId)

	{

	if (aItemId == Bookmark::KRootItemID)

		{

		return iRoot;

		}

	CBookmarkBase* item = NULL;

	TInt index = 0;

	TInt count = 0;

	// the top bit of the id indicates whether the id is a folder or bookmark

	TInt topBitSet = aItemId & KFolderIdMaskID;

	if (topBitSet == 0)

		{

		// item is a bookmark

		count = iBookmarkList.Count();

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

			{

			if (iBookmarkList[index]->Id() == aItemId)