/*
* 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 )
		{
		/* testing */
		// 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 );
	iObjectDefs.AppendL( object );
	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 );
	iObjectDefs.AppendL( object );
	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 );
	iRelationDefs.AppendL( relation );
	CleanupStack::Pop( relation );
	}


void CMdsNamespaceDef::AddRelationDefL( TDefId aId, const TDesC& aRelationName )
	{
	CMdsRelationDef* relation = CMdsRelationDef::NewLC( aRelationName );
	relation->SetId(aId);
	iRelationDefs.AppendL( relation );
	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 );
	iEventDefs.AppendL( event );
	CleanupStack::Pop( event );
	}

void CMdsNamespaceDef::AddEventDefL( TDefId aId, const TDesC& aEventName, TInt32 aPriority )
	{
	CMdsEventDef* event = CMdsEventDef::NewLC( aEventName, aPriority );
	event->SetId(aId);
	iEventDefs.AppendL( event );
	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;
		}
	
	const TInt count = iObjectDefs.Count();
	
	for ( TInt i = 0; i < count; ++i )
		{
		if( iObjectDefs[i]->GetId() == aId )
			{
			return iObjectDefs[i];
			}
		}
	return NULL;
	}

const CMdsEventDef* CMdsNamespaceDef::GetEventByIdL( TDefId aId ) const
	{
	const TInt count = iEventDefs.Count();
	
	for ( TInt i = 0; i < count; ++i )
		{
		if( iEventDefs[i]->GetId() == aId )
			{
			return iEventDefs[i];
			}
		}
	return NULL;
	}

const CMdsRelationDef* CMdsNamespaceDef::GetRelationByIdL( TDefId aId ) const
	{
	const TInt count = iRelationDefs.Count();
	
	for ( TInt i = 0; i < count; ++i )
		{
		if( iRelationDefs[i]->GetId() == aId )
			{
			return iRelationDefs[i];
			}
		}
	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 )
			{
			iObjectDefs.AppendL( aNamespace->iObjectDefs[i] );
			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 )
			{
			iRelationDefs.AppendL( aNamespace->iRelationDefs[i] );
			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 )
			{
			iEventDefs.AppendL( aNamespace->iEventDefs[i] );
			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();
		}

	// everything is ok, so set the flags
	SetStoredInDB();
	SetTableStoredInDB();
	}
	
TUint32 CMdsNamespaceDef::RequiredBufferSize()
	{
	TUint32 bufferSize = sizeof(TMdCNamespaceDef) + CMdsItemDef::RequiredBufferSize();

	const TInt objectDefsCount = iObjectDefs.Count();
	bufferSize += (objectDefsCount + 1) * sizeof( TMdCObjectDef);
	// base object def
	bufferSize += iBaseObject->RequiredBufferSize();

	// objectdefs
	for ( TInt i = 0; i < objectDefsCount; ++i )
		{
		bufferSize += iObjectDefs[i]->RequiredBufferSize();
		}

	// eventdefs
	const TInt eventDefsCount = iEventDefs.Count();
	bufferSize += eventDefsCount * sizeof( TMdCEventDef );
	for ( TInt i = 0; i < iEventDefs.Count(); ++i )
		{
		bufferSize += iEventDefs[i]->RequiredBufferSize();
		}

	// relationdefs
	const TInt relationDefsCount = iRelationDefs.Count();
	bufferSize += relationDefsCount * sizeof( TMdCRelationDef);
	for ( TInt i = 0; i < iRelationDefs.Count(); ++i )
		{
		bufferSize += iRelationDefs[i]->RequiredBufferSize();
		}

	return bufferSize;
	}

TMdCOffset CMdsNamespaceDef::SerializeL(CMdCSerializationBuffer& aBuffer, TMdCOffset aFreeSpace)
	{
	const TMdCOffset namespaceDefOffset = aBuffer.Position();
	TMdCNamespaceDef namespaceDef;
	// get const data and store Name
	namespaceDef.iDefId = GetId();
	namespaceDef.iReadOnly = GetReadOnly();
	namespaceDef.iName.iPtr.iCount = GetName().Length();
	namespaceDef.iName.iPtr.iOffset = aFreeSpace;
	aBuffer.PositionL( aFreeSpace );
	aFreeSpace = CMdsItemDef::SerializeL( aBuffer );

	// calculate necessary stuff for objectDefs
	const TInt objectDefsCount = iObjectDefs.Count(); 
	namespaceDef.iObjectDefs.iPtr.iCount = objectDefsCount + 1; // one extra for base object def
	namespaceDef.iObjectDefs.iPtr.iOffset = aFreeSpace;

	// create space for objectDefs
	aFreeSpace += (objectDefsCount + 1) * sizeof(TMdCObjectDef);
	
	aBuffer.PositionL( namespaceDef.iObjectDefs.iPtr.iOffset ); // one extra for base object def
	aFreeSpace = iBaseObject->SerializeL( aBuffer, aFreeSpace );

	for ( TInt i = 0; i < objectDefsCount; ++i )
		{
		aBuffer.PositionL( namespaceDef.iObjectDefs.iPtr.iOffset
				+ (i+1) * sizeof(TMdCObjectDef) ); // one extra for base object def
		// write object
		aFreeSpace = iObjectDefs[i]->SerializeL( aBuffer, aFreeSpace );
		}

	// calculate necessary stuff for eventDefs
	const TInt eventDefsCount = iEventDefs.Count();
	namespaceDef.iEventDefs.iPtr.iCount = eventDefsCount;
	namespaceDef.iEventDefs.iPtr.iOffset = aFreeSpace;

	// create space for eventDefs
	aFreeSpace += eventDefsCount * sizeof(TMdCEventDef);

	for ( TInt i = 0; i < eventDefsCount; ++i )
		{
		aBuffer.PositionL( namespaceDef.iEventDefs.iPtr.iOffset + i * sizeof(TMdCEventDef) );
		// write event
		aFreeSpace = iEventDefs[i]->SerializeL( aBuffer, aFreeSpace );
		}

	// calculate necessary stuff for relationDefs
	const TInt relationDefsCount = iRelationDefs.Count();
	namespaceDef.iRelationDefs.iPtr.iCount = relationDefsCount;
	namespaceDef.iRelationDefs.iPtr.iOffset = aFreeSpace;

	// create space for eventDefs
	aFreeSpace += relationDefsCount * sizeof(TMdCRelationDef);

	for ( TInt i = 0; i < relationDefsCount; ++i )
		{
		aBuffer.PositionL( namespaceDef.iRelationDefs.iPtr.iOffset + i * sizeof(TMdCRelationDef) );
		// write relation
		aFreeSpace = iRelationDefs[i]->SerializeL( aBuffer, aFreeSpace );
		}
	
	// store namespaceDef itself
	aBuffer.PositionL( namespaceDefOffset );
	namespaceDef.SerializeL( aBuffer );

	return aFreeSpace;
	}
	

const CMdsPropertyDef* CMdsNamespaceDef::GetPropertyL( TDefId aId ) const
	{
	const CMdsPropertyDef* propertyDef = iBaseObject->GetPropertyByIdL( aId );

	if ( propertyDef )
		{
		return propertyDef;
		}

	const TInt count = iObjectDefs.Count();
	
	for ( TInt i = 0; i < count; ++i )
		{
		const CMdsPropertyDef* objectPropertyDef = iObjectDefs[i]->GetPropertyByIdL( aId );
		if ( objectPropertyDef )
			{
			return objectPropertyDef;
			}
		}

	return NULL;
	}

/**
 * Initialize static variables
 */

CMdsObjectDef* CMdsNamespaceDef::iBaseObject = NULL;