/*

* Copyright (c) 2007-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:  Metadata schema container within server

*

*/

#include <e32cmn.h>

#include <charconv.h>

#include <convgeneratedcpp.h>

#include <badesca.h>

#include <bautils.h>

#include <e32math.h>

#include <pathinfo.h>

#include <mdeconstants.h>

#include "mdsimportexport.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdcdef.h"

#include "mdsnamespacedef.h"

#include "mdsobjectdef.h"

#include "mdccommon.h"

#include "mdspropertydef.h"

#include "mdsschema.h"

#include "mdssqliteconnection.h"

#include "mdsdbconnectionpool.h"

#include "mdcserializationbuffer.h"

#include "mdssqlobjectmanipulate.h"

#include "mdsrelationdef.h"

#include "mdseventdef.h"

#include "mdsfindsqlclausedef.h"

#include "mdsclausebuffer.h"

#include "mdsmaintenanceengine.h"

#include "mdssqldbmaintenance.h"

#include "mdspreferences.h"

#include "mdscommoninternal.h"

const TInt KMdsMaxUriLenght = KMaxFileName;

const TChar KMdsLineFeed = '\n';

const TInt KMdsMaxLogLineLenght( 2056 );

_LIT( KMdsErrorLogDirectory, "Metadata" );

_LIT( KMdsErrorLogFilename, "importerror.log" );

// keyword definitions in import file

_LIT8( KMdsKeywordComment,     "//" );

_LIT8( KMdsKeywordNamespace,   "namespace" );

_LIT8( KMdsKeywordObjectDef,   "object" );

_LIT8( KMdsKeywordPropertyDef, "property" );

_LIT8( KMdsKeywordRelationDef, "relationdef" );

_LIT8( KMdsKeywordEventDef,    "eventdef" );

_LIT8( KMdsKeywordVersion, "version" );

_LIT8( KMdsKeywordObject,   "object" );

_LIT8( KMdsKeywordProperty, "property" );

_LIT8( KMdsKeywordFreeText, "freetext" );

_LIT8( KMdsKeywordRelation, "relation" );

_LIT8( KMdsKeywordEvent,    "event" );

_LIT8( KExportMetadataNewLine, "\r\n" );

_LIT8( KExportMetadataSpace, " " );

_LIT8( KExportMetadataQuotationMark, "\"" );

_LIT8( KExportMetadataTimeFormat, "%04d%02d%02d%02d%02d%02d" );

_LIT( KMdsKeywordMinValue, "min" );

_LIT( KMdsKeywordMaxValue, "max" );

_LIT( KMdsKeywordDefValue, "def" );

/**

 * NewLC

 */

CMdsImportExport* CMdsImportExport::NewLC()

	{

	CMdsImportExport* ret = new(ELeave) CMdsImportExport();

	CleanupStack::PushL( ret );

	ret->ConstructL();

	return ret;

	}

/**

 * NewL

 */

CMdsImportExport* CMdsImportExport::NewL()

	{

	CMdsImportExport* ret = CMdsImportExport::NewLC();

	CleanupStack::Pop( ret );

	return ret;

	}

/**

 * Constructor

 */

CMdsImportExport::CMdsImportExport() : iLastDriveNumber ( -1 )

	{

	}

/**

 * Default destructor

 */

CMdsImportExport::~CMdsImportExport()

	{

   	delete iConverter;

    iFs.Close();

   	delete iBuffer;

   	delete iSchema;

	}

/**

 * ConstructL

 */

void CMdsImportExport::ConstructL()

	{

	iSchema = CMdsSchema::NewL();

    iConverter = CCnvCharacterSetConverter::NewL();

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

    iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iFs );

	iBuffer = NULL;

    iLastObjectDef = NULL;

	}

void CMdsImportExport::ImportSchemaFromFileL( const TDesC& aFileName,

							CMdsSchema& aSchema, TUint32 aVendorId )

    {

    iDefaultSchema = &aSchema;

    iVendorId = aVendorId;

    if ( !iDefaultSchema->iBaseObject )

    	{

    	// If the default schema doesn't already have a base object, add one to iSchema together

    	// with default namespace.

    	iSchema->AddDefaultObjectL();

		iDefaultSchema->iBaseObject = iSchema->iBaseObject;

		iSchema->AddDefaultNamespaceL();

    	}

    else

    	{

    	iSchema->iBaseObject = iDefaultSchema->iBaseObject;

    	}

	iReadStream.PushL();

	// Read the schema file.

	TInt fileOpenStatus = iReadStream.Open( iFs, aFileName, EFileStreamText );

	if (fileOpenStatus != KErrNone)

		{

	    iSchema->iBaseObject = NULL;

	    iDefaultSchema = NULL;

	    _LIT( KError, "Failed to open schema file" );

    	LogError( KError );

		User::Leave( fileOpenStatus );

		}

    iFileName.Copy( aFileName );

    iLineNumber = 0;

    iLastObjectDef = NULL;

    if ( aFileName == KSchemaImportFile || aFileName == KSchemaRomImportFile )

    	{

    	iVersionFlags = EVersionNone;

    	}

    else

    	{

    	iVersionFlags = EVersionAlreadyRead;

    	}

    // start reading lines from the schema file

    while( ETrue )

        {

        TRAPD( e, iReadStream.ReadL( iLine, KMdsLineFeed ) );

        if ( e == KErrEof ) break; // succesful exit

        else if ( e != KErrNone )

            {

		    iSchema->iBaseObject = NULL;

		    iDefaultSchema = NULL;

		    _LIT( KError, "Failed to read line from schema file" );

 	   		LogError( KError );

			User::Leave( e );

            }

        ++iLineNumber;

        if ( iLine.Length() > 0 )

            {

            // parse the line

            TLex8 parser( iLine );

            TRAP( e, ImportSchemaLineL( parser ) );

            if ( e != KErrNone )

            	{

			    iSchema->iBaseObject = NULL;

			    iDefaultSchema = NULL;

			    _LIT( KError, "Schema corrupted" );

            	LogError( KError );

            	User::Leave( e );

            	}

            }

        }

    CleanupStack::PopAndDestroy( &iReadStream ); // Closes stream.

    TRAPD( err, aSchema.MergeNamespacesL( *iSchema ) );

    iSchema->iBaseObject = NULL;

    iDefaultSchema = NULL;

    iVendorId = 0;

    if ( err != KErrNone )

    	{

    	User::Leave( err );

    	}

    }

/**

 * ImportL imports a single line of data

 */

void CMdsImportExport::ImportSchemaLineL( TLex8& aParser )

    {

    TPtrC8 token = aParser.NextToken();

    // valid keywords in beginning of line

    if ( token.Length() == 0 || token.Left(2) == KMdsKeywordComment )

        {

        // ignore

        return;

        }

    else if ( token == KMdsKeywordVersion )

        {

        ImportSchemaVersionL( aParser );

        }

    else if ( !(iVersionFlags & EVersionAlreadyRead ) )

        {

        User::Leave( KErrCorrupt );

        }

    else if ( token == KMdsKeywordNamespace )

        {

        ImportSchemaNamespaceL( aParser );

        return;

        }

    else if ( token == KMdsKeywordObjectDef )

        {        

        ImportSchemaObjectDefL( aParser );

        }

    else if(token == KMdsKeywordPropertyDef )

    	{

    	ImportSchemaPropertyDefL( aParser );

    	}

    else if ( token == KMdsKeywordRelationDef )

        {

        ImportSchemaRelationDefL( aParser );

        }

    else if ( token == KMdsKeywordEventDef )

        {

        ImportSchemaEventDefL( aParser );

        }

    else

        {

        _LIT( KError, "Keyword not recognized" );

        LogError( KError );

        User::Leave( KErrCorrupt );

        }

    TPtrC8 tokenLast = aParser.NextToken();

    if ( tokenLast.Length() != 0 && tokenLast.Left(2) != KMdsKeywordComment )

    	{

    	_LIT( KMdsUnknownToken, "Undefined schema item" );

    	LogError( KMdsUnknownToken );

    	User::Leave( KErrCorrupt );

    	}

    }

/**

 * Schema import checklist:

 *	1. Are all the namespaces new? If not, discard any duplicates

 *	2. Do all the (object/event/relation) defs about to be imported actually 

 *	   belong to a proper namespace (which is also not read-only)? If not, discard

 */

// ------------------------------------------------

// ImportSchemaNamespaceL

// ------------------------------------------------

//

void CMdsImportExport::ImportSchemaNamespaceL( TLex8& aParser )

    {

    // namespace <name> <readonly>

    TBuf16<KMdsMaxUriLenght> name;

    User::LeaveIfError( ImportText( name, aParser ) );

    TInt ro = 0;

    TBool readOnly = EFalse;

    User::LeaveIfError( ImportNum( ro, aParser ) );

    readOnly = ro ? ETrue : EFalse;

    // Check out if the namespace already exists

	if ( iSchema->GetNamespace( name ) )

		{

		return;

		}

	// in case there is namespace in old schema

	CMdsNamespaceDef* actualNamespace = iDefaultSchema->GetNamespace( name );

	if ( actualNamespace )

		{

		iSchema->NamespaceAddL( actualNamespace->GetName(),

                actualNamespace->GetReadOnly(), actualNamespace->GetVendorId(),

                actualNamespace->GetId() );

		return;

		}

	// Ok, the namespace is new

	iSchema->NamespaceAddL( name, readOnly, iVendorId );

    }

// ------------------------------------------------

// ImportSchemaObjectDefL

// ------------------------------------------------

//

void CMdsImportExport::ImportSchemaObjectDefL( TLex8& aParser )

    {

    // First read the name of the namespace.

    TBuf16<KMdsMaxUriLenght> name;

    User::LeaveIfError( ImportText( name, aParser ) );

	CMdsNamespaceDef* actualNamespace = iSchema->GetNamespace( name );

	if ( !actualNamespace )

		{

        actualNamespace = iDefaultSchema->GetNamespace( name );

		if ( !actualNamespace )

			{

			_LIT( KMdsNamespaceNotFound, "Namespace not found !!!" );

			LogError( KMdsNamespaceNotFound );

	    	User::Leave( KErrAccessDenied );

			}

		CMdsNamespaceDef* nmsp = iSchema->NamespaceAddL(

                actualNamespace->GetName(), actualNamespace->GetReadOnly(),

				actualNamespace->GetVendorId() );

		if ( !actualNamespace->GetFirstRead() )

			{

			nmsp->UnsetFirstRead();

			}

		actualNamespace = nmsp;

		}

    if ( actualNamespace->GetReadOnly() && !actualNamespace->GetFirstRead() )

    	{

    	iLastObjectDef = NULL;

    	_LIT( KError, "Namespace not allowed" );

    	LogError( KError );

    	User::Leave( KErrAccessDenied );

    	}

    // Next read the name of the object.

    TBuf16<KMdsMaxUriLenght> nameObject;

    User::LeaveIfError( ImportText( nameObject, aParser ) );

    if ( nameObject == MdeConstants::Object::KBaseObject )

    	{

    	_LIT( KError, "Cannot redefine Object" );

		LogError( KError );

    	User::Leave( KErrArgument );

    	}

    // Next read the name of the parent object.

    User::LeaveIfError( ImportText( name, aParser ) );

    // Add new object definition to the DB.

    TRAPD( err, iLastObjectDef = actualNamespace->AddObjectDefL( nameObject, name, iDefaultSchema ) );

    if ( err != KErrNone && err != KErrAlreadyExists  )

   		{

   		User::Leave( err );

    	}

    // Finally read object flags (currently only two values: 0/1).

    TInt flags;

    CMdsObjectDef::TObjectDefFlags objFlags = CMdsObjectDef::EObjectDefFlagsNone;

    User::LeaveIfError( ImportNum(flags, aParser) );

    switch( flags )

    	{

    	case CMdsObjectDef::EObjectDefFlagsNone:

    		objFlags = CMdsObjectDef::EObjectDefFlagsNone;

    		break;

    	case CMdsObjectDef::EObjectDefFlagsContext:

    		objFlags = CMdsObjectDef::EObjectDefFlagsContext;

    		break;

    	default:

    		_LIT( KUnsupportedFlag, "Unsupported flag" );

    		LogError( KUnsupportedFlag );

    		User::Leave( KErrCorrupt );

    	}

    iLastObjectDef->SetFlags( objFlags );

    }

// ------------------------------------------------

// ImportSchemaPropertyDefL

// ------------------------------------------------

//

void CMdsImportExport::ImportSchemaPropertyDefL( TLex8& aParser )

	{

	// property  <name>  <readonly> <mandatory>  <type> <minv> <maxv>

    _LIT( KMinMaxWrongValue, "Min value is bigger then max" );

    _LIT( KWrongValue,       "Min or max value is incorrect" );

    _LIT( KTextWrongValue,   "Min or max text value is incorrect" );

    // Property definitions always come immediately after object definitions in a schema file.

    // If there is no object definition before property definitions, it's an error.

	if ( !iLastObjectDef )

		{

		_LIT( KNoLastObject, "Try to add to no existing object" );

		LogError( KNoLastObject );

		User::Leave( KErrNotFound );

		}

	// Read property name.

    TBuf16<KMdsMaxUriLenght> name;

    User::LeaveIfError( ImportText( name, aParser ) );

    if ( iLastObjectDef->GetProperty( name ) )

    	{

    	_LIT( KError, "Property already exists" );

		LogError( KError );

		User::Leave( KErrArgument );

    	}

    // Read read-only and mandatory flags.

    TBool readOnly, mandatory;

	User::LeaveIfError( ImportNum( readOnly, aParser ) );

	User::LeaveIfError( ImportNum( mandatory, aParser ) );

	// Read property type.

    TPropertyType type;

    TInt32 readType;

    User::LeaveIfError( ImportNum( readType, aParser ) );

    type = static_cast<TPropertyType>(readType);

    // Depending on the property type read the next two parameters with the correct data type.

    TInt error = KErrNone;

    switch( type )	

    	{

    	case EPropertyBool:

    		{

    		TInt32  minVal32,

    		        maxVal32;

    		error = SetMinMaxDefValueL<TInt32>( CheckForConstant(aParser), minVal32, 0, 1, 0 );

       		if ( error < KErrNone )

    			{

    			User::LeaveIfError( ImportNum( minVal32, aParser ) );

    			}

    		error = SetMinMaxDefValueL<TInt32>( CheckForConstant(aParser), maxVal32, 0, 1, 1 );

       		if ( error < KErrNone )

    			{

    			User::LeaveIfError( ImportNum( maxVal32, aParser ) );

    			}

       		CheckNoMoreNumericParametersL( aParser );

    		// boolean cannot have different values

    		minVal32 = 0;

    		maxVal32 = 1;

    		// Add this property to the previously defined object.

    		iLastObjectDef->AddPropertyL( name, type, minVal32, maxVal32, readOnly, mandatory, EFalse );

    		break;

    		}

    	case EPropertyInt8:

    	case EPropertyUint8:

    	case EPropertyInt16:

    	case EPropertyUint16:

    	case EPropertyInt32:

    		{

    		TInt32  minVal32,

    		        maxVal32;

    		const TInt32 KMinVal32 = type == EPropertyInt8 ? KMinTInt8 :

    		                          type == EPropertyInt16 ? KMinTInt16 :

    		                           type == EPropertyInt32 ? KMinTInt32 : 0;

    		const TInt32 KMaxVal32 = type == EPropertyInt8 ? KMaxTInt8 :

    		                          type == EPropertyUint8 ? KMaxTUint8 :

    		                           type == EPropertyInt16 ? KMaxTInt16 :

    		                            type == EPropertyUint16 ? KMaxTUint16 : KMaxTInt32;

   			error = SetMinMaxDefValueL<TInt32>( CheckForConstant(aParser),

   					minVal32, KMinVal32, KMaxVal32, 0 );

       		if ( error < KErrNone )

    			{

    		    User::LeaveIfError( ImportNum( minVal32, aParser ) );

    			}

   			error = SetMinMaxDefValueL<TInt32>( CheckForConstant(aParser),

   					maxVal32, KMinVal32, KMaxVal32, KMaxVal32 );

       		if ( error < KErrNone )

    			{

        		User::LeaveIfError( ImportNum( maxVal32, aParser ) );

    			}

		    if ( minVal32 > maxVal32 )

		    	{

		    	LogError( KMinMaxWrongValue );