// 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 the bookmark item base class.
// @internalComponent
// 
//

//#include <bookmarkdef.h>
#include "bkmrk.h"
#include "bkmrkfolder.h"

CBookmarkBase::CBookmarkBase(CBookmarkDb& aDb, CRepository& aRepository)
	: CRepositoryAccessor(), iDatabase(aDb), iRefCount(0), iId(Bookmark::KNullItemID), iParent(NULL), iFlags(EFlagPublic|EFlagWritable)
	{
	SetRepository(aRepository);
	iStatus = EStatusCreating;
	}

CBookmarkBase::~CBookmarkBase()
	{
	if (iParent)
		{
		iParent->Remove(*this);
		}
	}

Bookmark::TItemId CBookmarkBase::Id()
	{
	return iId;
	}

void CBookmarkBase::AssignIdL()
	{
	iId = NextIndexL();
	if (Type() == Bookmark::ETypeFolder)
		{
		iId |= KFolderIdMaskID;
		}
	}

void CBookmarkBase::SetId(Bookmark::TItemId aId)
	{
	iId = aId;
	}

RBkNode CBookmarkBase::OpenItemL()
	{
	RBkNode item;
	item.SetItem(*this);
	return item;
	}

void CBookmarkBase::SetDirty()
	{
	if (!iDatabase.IsLoading())
		{
		CRepositoryAccessor::SetDirty();
		}
	}

Bookmark::TItemId CBookmarkBase::ParentId() const
	{
	return iParentId;
	}

CBookmarkFolder* CBookmarkBase::Parent() const
	{
	return iParent;
	}

// Should not be used. Use CBookmarkFolder::AppendL or InsertL
// to an item to another folders.
void CBookmarkBase::SetParentL(CBookmarkFolder& aNewParent)
	{
	// No item should set it's parent to itself
	__ASSERT_ALWAYS(&aNewParent != this, User::Panic(Bookmark::KBookmarkErrParent, Bookmark::KErrCyclicLoop));
	LeaveIfNotWritableL();

	// Ensure we're not trying to set the parent of an item to a folder it owns.
	if (this->Type() == Bookmark::ETypeFolder &&
		aNewParent.IsAChild(static_cast<CBookmarkFolder*>(this)))
		{
		User::Leave(Bookmark::KErrCyclicLoop);
		}

	iParent = &aNewParent;
	iParentId = aNewParent.Id();
	SetDirty();
	}

void CBookmarkBase::SetTitleL(const TDesC& aTitle)
	{
	// The aTitle must be smaller that the maximim descriptor storage size
	__ASSERT_ALWAYS(aTitle.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));
	
	if (Type() == Bookmark::ETypeFolder && 
		(iDatabase.FindFolder(aTitle) != NULL || 
		iDatabase.FindUnloadedFolder(aTitle) != NULL))
		{
		User::Leave(Bookmark::KErrTitleAlreadyUsed);
		}

	LeaveIfNotWritableL();
	if (iTitle)
		{
		delete iTitle;
		}

	iTitle = NULL;
	iTitle = aTitle.AllocL();
	SetDirty();
	}

const TDesC& CBookmarkBase::Title() const
	{
	if ( !iTitle )
		{
		return KNullDesC;
		}
 	return *iTitle;
	}

void CBookmarkBase::IncRefCount()
	{
	++iRefCount;
	}

void CBookmarkBase::DecRefCount()
	{
	__ASSERT_ALWAYS(iRefCount > 0, User::Panic(Bookmark::KBookmarkErrNegativeRefCount, KErrGeneral));
	--iRefCount;
	}

TUint CBookmarkBase::RefCount()
	{
	return iRefCount;
	}

TBool CBookmarkBase::IsPublic()
	{
	return iFlags & EFlagPublic;
	}

void CBookmarkBase::SetPublicL(TBool aPublic)
	{
	LeaveIfNotWritableL();
	
	// The home page cannot be set as private
	if (!aPublic &&
		Type() == Bookmark::ETypeBookmark &&		
		static_cast<CBookmark*>(this)->IsHomePage())
		{
		User::Leave(Bookmark::KErrOperationDenied);
		}
	
	// You can't change the public-ness of an item in public only and private only modes.
	if (iDatabase.Visibility() == Bookmark::EVisibilityPublic || iDatabase.Visibility() == Bookmark::EVisibilityPrivate)
		{
		User::Leave(KErrPermissionDenied);
		}
		
	if (aPublic)
		{
		iFlags = iFlags | EFlagPublic;
		}
	else
		{
		RThread thread;
		TSecurityInfo secInfo(thread);
		SetOwnerL(secInfo.iSecureId);
		}
	SetDirty();
	}

TBool CBookmarkBase::IsWritable()
	{
	return iFlags & EFlagWritable;
	}

void CBookmarkBase::SetWritableL(TBool aWritable)
	{
	if (aWritable)
		{
		LeaveIfNotInManagerModeL ();
		iFlags = iFlags | EFlagWritable;
		}
	else
		{
		iFlags = iFlags & ~EFlagWritable;
		}
	SetDirty();
	}

TBool CBookmarkBase::IsOrphaned()
	{
	return iFlags & EFlagOrphaned;
	}

void CBookmarkBase::SetOrphaned(TBool aOrphaned)
	{
	if (aOrphaned)
		{
		iFlags = iFlags | EFlagOrphaned;
		}
	else
		{
		iFlags = iFlags & ~EFlagOrphaned;
		}
	}

void CBookmarkBase::GetOwnerL(TSecureId& aOwner)
	{
	TInt id = Bookmark::KNoOwnerId;
	TInt err = iRepository->Get(IndexBase() + KCmnOwnerIndex, id);
	if (err != KErrNone && err != KErrNotFound)
		{
		User::Leave(err);
		}
	aOwner.iId = static_cast<TUint32>(id);
	}

void CBookmarkBase::SetOwnerL(TSecureId aOwner)
	{
	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager )
		{
		RThread thread;
		TSecurityInfo secInfo ( thread );
		
		if ( aOwner != secInfo.iSecureId )
			{
			User::Leave ( KErrPermissionDenied );
			}
		}
	
	// The owner is never stored in the class as a member variable
	if (iStatus == EStatusCreating)
		{
		// the owner id is not stored in the class so it can't be set until the bookmark 
		// had been committed at least once
		User::Leave(Bookmark::KErrNotCommitted);
		}
	else
		{
		TInt id = Bookmark::KNoOwnerId;
		if (aOwner != Bookmark::KNoOwnerId)
			{
			id = static_cast<TInt>(aOwner.iId);
			}
		User::LeaveIfError(iRepository->Set(IndexBase() + KCmnOwnerIndex, id));
		}
	iFlags = iFlags & ~EFlagPublic;
	SetDirty();
	}

TInt CBookmarkBase::Rank()
	{
	return iRank;
	}

void CBookmarkBase::LeaveIfNotWritableL()
	{
	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager && 
		!iDatabase.IsLoading() && 
		!IsWritable())
 		{
 		User::Leave(Bookmark::KErrReadOnly);
 		}	
 	}

void CBookmarkBase::LeaveIfNotInManagerModeL ()
	{
	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager )
 		{
		User::Leave ( KErrPermissionDenied );
 		}
 	}

TBool CBookmarkBase::IsAChild(CBookmarkFolder* aAncestor)
	{
	CBookmarkFolder* parent = iParent;
	for (TInt folderDepth = 0; parent != NULL && folderDepth < Bookmark::KMaxFolderDepth; ++folderDepth)
		{
		if (parent == aAncestor)
			{
			return ETrue;
			}
		parent = parent->Parent();
		}

	return EFalse;
	}

CBkmrkProperties& CBookmarkBase::ExtendedPropertiesL()
	{
	if (Type() == Bookmark::ETypeFolder)
		{
		return static_cast<CBookmarkFolder*>(this)->BkmrkPropertiesL();
		}
	else
		{
		return static_cast<CBookmark*>(this)->BkmrkExtendedPropertiesL();
		}		
	}

void CBookmarkBase::TransNewL()
	{
	TUint32 indexBase = IndexBase();
	// create entries in the repository
	iRepository->Create(indexBase + KCmnTitleIndex, Title());
	iRepository->Create(indexBase + KCmnParentIndex, static_cast<TInt>(iParent->Id()));
	iRepository->Create(indexBase + KCmnFlagsIndex, static_cast<TInt>(iFlags));
	TInt rank = iParent->Index(*this);
	iRepository->Create(indexBase + KCmnRankIndex, rank);

	TInt id = Bookmark::KNoOwnerId;
	if (!(iFlags & EFlagPublic))
		{
		RThread thread;
		TSecurityInfo secInfo(thread);
		id = static_cast<TInt>(secInfo.iSecureId);
		}
	iRepository->Create(indexBase + KCmnOwnerIndex, id);
	}

void CBookmarkBase::TransSaveL()
	{
	TUint32 indexBase = IndexBase();
	// create entries in the repository
	iRepository->Set(indexBase + KCmnTitleIndex, Title());
	iRepository->Set(indexBase + KCmnParentIndex, static_cast<TInt>(iParent->Id()));
	iRepository->Set(indexBase + KCmnFlagsIndex, static_cast<TInt>(iFlags));
	TInt rank = iParent->Index(*this);
	iRepository->Set(indexBase + KCmnRankIndex, rank);
	}

void CBookmarkBase::TransLoadL()
	{
	TUint32 indexBase = IndexBase();
	HBufC* titleBuffer = HBufC::NewLC(Bookmark::KMaxDescriptorLength);
	TPtr titlePtr = titleBuffer->Des();
	User::LeaveIfError(iRepository->Get(indexBase + KCmnTitleIndex, titlePtr));
	delete iTitle;
	iTitle = NULL;
	iTitle = titlePtr.AllocL();
	CleanupStack::PopAndDestroy(titleBuffer);

	TInt retInt = 0;
	User::LeaveIfError(iRepository->Get(indexBase + KCmnParentIndex, retInt));
	iParentId = static_cast<Bookmark::TItemId>(retInt);
	User::LeaveIfError(iRepository->Get(indexBase + KCmnFlagsIndex, retInt));
	iFlags = static_cast<TUint32>(retInt);
	User::LeaveIfError(iRepository->Get(indexBase + KCmnRankIndex, iRank))	;
	SetClean();
	}

void CBookmarkBase::TransRemoveL()
	{
	TUint32 indexBase = IndexBase();
	iRepository->Delete(indexBase + KCmnTitleIndex);
	iRepository->Delete(indexBase + KCmnParentIndex);
	iRepository->Delete(indexBase + KCmnFlagsIndex);
	iRepository->Delete(indexBase + KCmnRankIndex);
	iRepository->Delete(indexBase + KCmnOwnerIndex);
	}