/*

* 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:  Class to hold description about one namespace and every object

*                it holds.

*

*/

#include "mdsnamespacedef.h"

#include "mdcdef.h"

#include "mdsobjectdef.h"

#include "mdsrelationdef.h"

#include "mdseventdef.h"

#include "mdssqliteconnection.h"

#include "mdsdbconnectionpool.h"

#include "mdcserializationbuffer.h"

#include "mdsschema.h"

#include "mdsindexer.h"

#include "mdeinternalerror.h"

#include <uriutils.h>

/**

 * NewLC

 */

CMdsNamespaceDef* CMdsNamespaceDef::NewLC( TDefId aId,

    const TDesC& aName, TBool aReadOnly, TUint32 aVendorId )

	{

	CMdsNamespaceDef* ret = new( ELeave ) CMdsNamespaceDef( aId, aReadOnly, aVendorId );

	CleanupStack::PushL( ret );

	ret->ConstructL( aName );

	return ret;

	}

/**

 * NewL

 */

CMdsNamespaceDef* CMdsNamespaceDef::NewL( TDefId aId, const TDesC& aName,

    TBool aReadOnly, TUint32 aVendorId )

	{

	CMdsNamespaceDef* ret = CMdsNamespaceDef::NewLC( aId, aName, aReadOnly, aVendorId );

	CleanupStack::Pop( ret );

	return ret;

	}

/**

 * ConstructL

 */

void CMdsNamespaceDef::ConstructL( const TDesC& aName )

	{

	// validate the URI of namespace

	TBool invalidChars = UriUtils::HasInvalidChars( aName );

	if( invalidChars )

		{

		User::Leave( KErrGeneral );

		}

	CMdsItemDef::ConstructL( aName );

	}

/**

 * Destructor

 */

CMdsNamespaceDef::~CMdsNamespaceDef()

	{

	// deleting objects

	iObjectDefs.ResetAndDestroy();

	iObjectDefs.Close();

	// deleting relations...

	iRelationDefs.ResetAndDestroy();

   	iRelationDefs.Close();

   	// deleting events...

    iEventDefs.ResetAndDestroy();

   	iEventDefs.Close();

	}

/**

 * AddObjectDefL

 */

CMdsObjectDef* CMdsNamespaceDef::AddObjectDefL( const TDesC& aObjectName, const TDesC& aParentName,

                                                CMdsSchema* aDefaultSchema )

	{

	if ( GetObjectDef( aObjectName ) )

		{

		// duplicate object

		User::Leave( KErrAlreadyExists );

		}

	CMdsObjectDef* parent = GetObjectDef( aParentName );

	if ( !parent )

		{

		// found namespace in default schema

		if ( aDefaultSchema )

			{

			CMdsNamespaceDef* namespaceDef = aDefaultSchema->GetNamespace( GetName() );

			if ( !namespaceDef )

				{

				User::Leave( KErrMdEUnknownNamespaceDef );

				}

			parent = namespaceDef->GetObjectDef( aParentName );

			}

		if( !parent )

			{

			User::Leave( KErrNotFound );

			}

		}

	CMdsObjectDef* object = CMdsObjectDef::NewLC( aObjectName, parent );

	CleanupStack::Pop( object );

	return object;

	}

/**

 * AddObjectDefL (private - add from DB)

 */

void CMdsNamespaceDef::AddObjectDefL( TDefId aId, TDefId aParentId, TInt aFlags, const TDesC& aName )

	{

	const CMdsObjectDef* parent = GetObjectByIdL( aParentId );

	if ( !parent )

		{

		User::Leave( KErrNotFound );

		}

	CMdsObjectDef* object = CMdsObjectDef::NewLC( aName, parent );

	object->SetFlags( (CMdsObjectDef::TObjectDefFlags)aFlags );

	object->SetId(aId);

	object->SetStoredInDB();

	CleanupStack::Pop( object );

	}

/**

 * FindObjectDefParent

 */

CMdsObjectDef* CMdsNamespaceDef::GetObjectDef( const TDesC& aObjectName ) const

	{

	if ( iBaseObject->GetName().Compare( aObjectName ) == 0 )

		{

		return iBaseObject;

		}

	const TInt count = iObjectDefs.Count();

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

		{

		if( iObjectDefs[i]->GetName().Compare( aObjectName ) == 0 )

			{

			return iObjectDefs[i];

			}

		}

	return NULL;

	}

void CMdsNamespaceDef::AddRelationDefL( const TDesC& aRelationName )

	{

	if ( GetRelationDef( aRelationName ) )

		{

		User::Leave( KErrAlreadyExists );

		}

	CMdsRelationDef* relation = CMdsRelationDef::NewLC( aRelationName );

	CleanupStack::Pop( relation );

	}

void CMdsNamespaceDef::AddRelationDefL( TDefId aId, const TDesC& aRelationName )

	{

	CMdsRelationDef* relation = CMdsRelationDef::NewLC( aRelationName );

	relation->SetId(aId);

	relation->SetStoredInDB();

	CleanupStack::Pop( relation );

	}

CMdsRelationDef* CMdsNamespaceDef::GetRelationDef( const TDesC& aRelationName ) const

	{

	const TInt count = iRelationDefs.Count();

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

		{

		if ( iRelationDefs[i]->GetName().Compare( aRelationName ) == 0 )

			{

			return iRelationDefs[i];

			}

		}

	return NULL;

	}

void CMdsNamespaceDef::AddEventDefL( const TDesC& aEventName, TInt32 aPriority )

	{

	if ( GetEventDef( aEventName ) )

		{

		User::Leave( KErrAlreadyExists );

		}

	CMdsEventDef* event = CMdsEventDef::NewLC( aEventName, aPriority );

	CleanupStack::Pop( event );

	}

void CMdsNamespaceDef::AddEventDefL( TDefId aId, const TDesC& aEventName, TInt32 aPriority )

	{

	CMdsEventDef* event = CMdsEventDef::NewLC( aEventName, aPriority );

	event->SetId(aId);

	event->SetStoredInDB();

	CleanupStack::Pop( event );

	}

CMdsEventDef* CMdsNamespaceDef::GetEventDef( const TDesC& aEventName ) const

	{

	const TInt count = iEventDefs.Count();

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

		{

		if ( iEventDefs[i]->GetName().Compare( aEventName ) == 0 )

			{

			return iEventDefs[i];

			}

		}

	return NULL;

	}

const CMdsObjectDef* CMdsNamespaceDef::GetObjectByIdL( TDefId aId ) const

	{

	if ( aId == KBaseObjectDefId ) // BaseObject (hardcoded)

		{

		return iBaseObject;

		}

	return NULL;

	}

const CMdsEventDef* CMdsNamespaceDef::GetEventByIdL( TDefId aId ) const

	{

	return NULL;

	}

const CMdsRelationDef* CMdsNamespaceDef::GetRelationByIdL( TDefId aId ) const

	{

	return NULL;

	}

void CMdsNamespaceDef::StoreToDBL( TBool aStoreOnlyNamespace )

	{

	_LIT( KMdsSqlClauseAddNamespaceDef, "INSERT INTO NamespaceDef(ReadOnly,VendorId,Name) Values(?,?,?);" );

    RRowData rowData;

    CleanupClosePushL( rowData );

	if ( !GetStoredInDB() )

		{

		rowData.AppendL( TColumn( GetReadOnly() ) );

		rowData.AppendL( TColumn( iVendorId ) );

		rowData.AppendL( TColumn( GetName().AllocL() ) );

		TDefId id = KNoDefId;

		id = MMdSIndexer::ExecuteAndGetIndexL(KMdsSqlClauseAddNamespaceDef,rowData);

		SetId( id );

		SetStoredInDB();

		}

	if (aStoreOnlyNamespace)

		{

		CleanupStack::PopAndDestroy( &rowData );

		return;

		}

	const TInt objectDefCount = iObjectDefs.Count();

	// add objectDef to DB

	for( TInt i = 0; i < objectDefCount; ++i )

		{

		iObjectDefs[i]->StoreToDBL( GetId() );

		}

	const TInt eventDefCount = iEventDefs.Count();

	// add relationDef to DB

	for( TInt i = 0; i < eventDefCount; ++i )

		{

		iEventDefs[i]->StoreToDBL( GetId() );

		}

	const TInt relationDefCount = iRelationDefs.Count();

	// add eventDef to DB

	for( TInt i = 0; i < relationDefCount; ++i )

		{

		iRelationDefs[i]->StoreToDBL( GetId() );

		}

	CleanupStack::PopAndDestroy( &rowData );

	}

void CMdsNamespaceDef::MergeObjectsL( CMdsNamespaceDef* aNamespace, const TBool& aDryRun )

	{

	const TInt count = aNamespace->iObjectDefs.Count();	

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

		{

		CMdsObjectDef* lObjectDef = GetObjectDef( aNamespace->iObjectDefs[i]->GetName() );

		if( lObjectDef )

			{

			lObjectDef->MergeL( aNamespace->iObjectDefs[i], aDryRun );

			}

		else if ( !aDryRun )

			{

			aNamespace->iObjectDefs[i]->SetAllNotStoredInDB();

			aNamespace->iObjectDefs[i] = NULL;

			}

		}

	}

void CMdsNamespaceDef::MergeRelationsL( CMdsNamespaceDef* aNamespace, const TBool& aDryRun )

	{

	const TInt count = aNamespace->iRelationDefs.Count();	

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

		{

		CMdsRelationDef* relation = GetRelationDef( aNamespace->iRelationDefs[i]->GetName() );

		if ( relation )

			{

			if ( *aNamespace->iRelationDefs[i] != *relation )

				{

				User::Leave( KErrAlreadyExists );

				}

			}

		else if ( !aDryRun )

			{

			aNamespace->iRelationDefs[i]->SetAllNotStoredInDB();

			aNamespace->iRelationDefs[i] = NULL;

			}

		}

	}

void CMdsNamespaceDef::MergeEventsL( CMdsNamespaceDef* aNamespace, const TBool& aDryRun )

	{

	const TInt count = aNamespace->iEventDefs.Count();

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

		{

		CMdsEventDef* event = GetEventDef( aNamespace->iEventDefs[i]->GetName() );

		if ( event )

			{

			if ( *aNamespace->iEventDefs[i] != *event )

				{

				User::Leave( KErrAlreadyExists );

				}

			}

		else if ( !aDryRun )

			{

			aNamespace->iEventDefs[i]->SetAllNotStoredInDB();

			aNamespace->iEventDefs[i] = NULL;

			}

		}

	}

void CMdsNamespaceDef::ImportFromDBL()

	{

	_LIT( KMdsQueryGetObjectDefs, "SELECT ObjectDefId,ParentDefId,Flags,Name FROM ObjectDef WHERE NamespaceDefId=?;" );

	_LIT( KMdsQueryGetRelationDefs, "SELECT RelationDefId,Name FROM RelationDef WHERE NamespaceDefId=?;" );

	_LIT( KMdsQueryGetEventDefs, "SELECT EventDefId,Priority,Name FROM EventDef WHERE NamespaceDefId=?;" );

	TDefId eId = KNoDefId;

	TInt32 objectParent = 0;

	TInt32 flags = 0;

	TPtrC name;

	// importing namespaces

	RRowData namespaceNumber;

	CleanupClosePushL( namespaceNumber );

	namespaceNumber.AppendL( TColumn( GetId() ) );

	RRowData getData;

	CleanupClosePushL( getData );

	CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	// OBJECTS

	RMdsStatement queryObject;

	CleanupClosePushL( queryObject );

	getData.AppendL( TColumn( eId ) );

	getData.AppendL( TColumn( objectParent ) );

	getData.AppendL( TColumn( flags ) );

	getData.AppendL( TColumn( EColumnHBuf16 ) );

	connection.ExecuteQueryL( KMdsQueryGetObjectDefs, queryObject, namespaceNumber );

	while( connection.NextRowL( queryObject, getData ) )

		{

		getData.Column( 0 ).Get( eId );

		getData.Column( 1 ).Get( objectParent );

		getData.Column( 2 ).Get( flags );

		getData.Column( 3 ).Get( name );

		AddObjectDefL( eId, objectParent, flags, name );

		getData.Column( 3 ).Free( );

		}

	CleanupStack::PopAndDestroy( &queryObject );

	getData.Reset();

	// RELATIONS

	RMdsStatement queryRelation;

	CleanupClosePushL( queryRelation );

	getData.AppendL( TColumn( eId ) );

	getData.AppendL( TColumn( EColumnHBuf16 ) );

	connection.ExecuteQueryL( KMdsQueryGetRelationDefs, queryRelation, namespaceNumber );

	while( connection.NextRowL( queryRelation, getData ) )

		{

		getData.Column( 0 ).Get( eId );

		getData.Column( 1 ).Get( name );

		AddRelationDefL( eId, name );

		getData.Column( 1 ).Free( );

		}

	CleanupStack::PopAndDestroy( &queryRelation );

	getData.Reset();

	// EVENTS

	TInt32 priority = 0;

	RMdsStatement queryEvent;

	CleanupClosePushL( queryEvent );

	getData.AppendL( TColumn( eId ) );

	getData.AppendL( TColumn( priority ) );

	getData.AppendL( TColumn( EColumnHBuf16 ) );

	connection.ExecuteQueryL( KMdsQueryGetEventDefs, queryEvent, namespaceNumber );

	while( connection.NextRowL( queryEvent, getData ) )

		{

		getData.Column( 0 ).Get( eId );

		getData.Column( 1 ).Get( priority );

		getData.Column( 2 ).Get( name );

		AddEventDefL( eId, name, priority );

		getData.Column( 2 ).Free( );

		}

	CleanupStack::PopAndDestroy( &queryEvent );

	CleanupStack::PopAndDestroy( 2, &namespaceNumber ); // getData, namespaceNumber

	const TInt count = iObjectDefs.Count();

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

		{

		iObjectDefs[i]->ImportFromDBL();