/*

* Copyright (c) 2006 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:  

*

*/

#include <f32file.h>

#include <bautils.h>

#include "ncdstorageimpl.h"

#include "ncddbstoragemanager.h"

#include "ncdfilestorageimpl.h"

#include "catalogsdebug.h"

#include "catalogsutils.h"

#include "catalogsconstants.h"

// ======== MEMBER FUNCTIONS ========

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

// ConstructL

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

//

void CNcdStorage::ConstructL( const TDesC& aNamespace )

    {

    DLTRACEIN( ("") );

    iNamespace.CreateL( aNamespace ); 

    iDirectory.Assign( EncodeFilenameLC( aNamespace, iOwner.FileSession() ) );

    CleanupStack::Pop(); // iDirectory

    HBufC* path = CurrentPathLC();

    DLTRACE(( _L("Creating the directory: %S"), path));

    // Create the directory

    BaflUtils::EnsurePathExistsL( iOwner.FileSession(), 

        *path );    

    CleanupStack::PopAndDestroy( path );

    DLTRACEOUT( ("") );   

    }

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

// ConstructL

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

//

void CNcdStorage::ConstructL( HBufC* aNamespace, HBufC* aDirectory )

    {

    DLTRACEIN( ("") );

    iNamespace.Assign( aNamespace ); 

    iDirectory.Assign( aDirectory );    

    HBufC* path = CurrentPathLC();

    DLTRACE(( _L("Creating the directory: %S"), path));

    // Create the directory

    BaflUtils::EnsurePathExistsL( iOwner.FileSession(), 

        *path );    

    CleanupStack::PopAndDestroy( path );

    DLTRACEOUT( ("") );   

    }

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

// NewL

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

//

CNcdStorage* CNcdStorage::NewL( MNcdStorageOwner& aOwner, 

    const TDesC& aNamespace )

    {

    CNcdStorage* self = CNcdStorage::NewLC( aOwner, aNamespace );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CNcdStorage* CNcdStorage::NewLC( MNcdStorageOwner& aOwner, 

    const TDesC& aNamespace )

    {

    CNcdStorage* self = new( ELeave ) CNcdStorage( aOwner );

    CleanupStack::PushL( self );

    self->ConstructL( aNamespace );

    return self;

    }

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

// NewL

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

//

CNcdStorage* CNcdStorage::NewL( MNcdStorageOwner& aOwner, 

    HBufC* aNamespace, HBufC* aDirectory )

    {

    CNcdStorage* self = new( ELeave ) CNcdStorage( aOwner );

    CleanupStack::PushL( self );

    self->ConstructL( aNamespace, aDirectory );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CNcdStorage::~CNcdStorage()

    {

    DLTRACEIN((""));

    iNamespace.Close();        

    iDirectory.Close();

    iDbStorages.ResetAndDestroy();    

    iFileStorages.ResetAndDestroy();

    }

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

// Gets an existing database storage or creates a new one

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

//

MNcdDatabaseStorage& CNcdStorage::DatabaseStorageL( const TDesC& aUid )

    {

    DLTRACEIN( ( _L("Uid: %S"), &aUid ) );

    TInt index = FindDbStorageByUid( aUid );

    CNcdDbStorageManager* db = NULL;

    if ( index == KErrNotFound ) 

        {

        RBuf path;

        CleanupClosePushL( path );

        path.CreateL( KMaxPath );

        DLTRACE( ("DB not found, creating new object" ) );

        // Creates the path

        CreateCurrentPathL( path, aUid );      

        DLTRACE(( _L("Checking if the directory exists: %S"),

            &path ));

        db = CNcdDbStorageManager::NewLC( FileSession(), aUid, path, 

            iDirectory );

        iDbStorages.AppendL( db );

        CleanupStack::Pop( db );

        CleanupStack::PopAndDestroy( &path );

        }

    else 

        {

        db = iDbStorages[index];

        }

    DASSERT( db );

    DLTRACEOUT( ( "db: %x", db ) );

    return *db;

    }

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

// Gets an existing file storage or creates a new one

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

//

MNcdFileStorage& CNcdStorage::FileStorageL( const TDesC& aUid )

    {

    DLTRACEIN( ( _L("Uid: %S"), &aUid ) );

    TInt index = FindFileStorageByUid( aUid );

    CNcdFileStorage* fs = NULL;

    if ( index == KErrNotFound ) 

        {

        RBuf path;

        CleanupClosePushL( path );

        path.CreateL( KMaxPath );

        CreateCurrentPathL( path, aUid );

        // Note: giving the owner of this object instead of giving *this

        fs = CNcdFileStorage::NewLC( iOwner, aUid, path );

        iFileStorages.AppendL( fs );

        CleanupStack::Pop( fs );        

        CleanupStack::PopAndDestroy( &path );

        }

    else 

        {

        fs = iFileStorages[index];

        }

    DASSERT( fs );

    DLTRACEOUT( ( _L("fs: %x"), fs ) );

    return *fs;    

    }

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

// Namespace getter 

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

//

const TDesC& CNcdStorage::Namespace() const

    {

    return iNamespace;

    }

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

// Directory getter 

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

//

const TDesC& CNcdStorage::Directory() const

    {

    return iDirectory;

    }

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

// File session getter

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

//    

RFs& CNcdStorage::FileSession()

    {

    return iOwner.FileSession();

    }

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

// Size getter

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

//    

TInt CNcdStorage::SizeL()

    {

    DLTRACEIN((""));

    HBufC* path = CurrentPathLC();

    TInt size = FileSystemAllocationL( FileSession(), *path );

    DLTRACEOUT(( _L("Size for path %S is %d bytes"), path, size ));

    CleanupStack::PopAndDestroy( path );

    return size;

    }

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

// Constructor

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

//    

CNcdStorage::CNcdStorage( MNcdStorageOwner& aOwner ) : iOwner( aOwner )

    {

    }

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

// Searches for a database by name

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

//

TInt CNcdStorage::FindDbStorageByUid( const TDesC& aUid )

    {

    for ( TInt i = 0; i < iDbStorages.Count(); ++i )

        {

        if ( iDbStorages[i]->Uid().Compare( aUid ) == 0 ) 

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// Searches for a file storage by name

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

//

TInt CNcdStorage::FindFileStorageByUid( const TDesC& aUid )

    {

    for ( TInt i = 0; i < iFileStorages.Count(); ++i )

        {

        if ( iFileStorages[i]->Uid().Compare( aUid ) == 0 ) 

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// Generates the current path

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

//

void CNcdStorage::CreateCurrentPathL( TDes& aPath, const TDesC& aUid ) const

    {

    iOwner.AppendRoot( aPath );

    DLTRACE(( _L("Adding namespace %S"), &iNamespace ));

    aPath.Append( iDirectory );

    aPath.Append( KDirectorySeparator );    

    DLTRACE(( _L("Adding uid %S"), &aUid ));

    aPath.Append( aUid );                

    aPath.Append( KDirectorySeparator );    

    // Create the directory

    BaflUtils::EnsurePathExistsL( iOwner.FileSession(), aPath );    

    }

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

// Storage path getter

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

//

HBufC* CNcdStorage::CurrentPathLC() const

    {

    HBufC* path = HBufC::NewLC( KMaxPath );

    TPtr ptr( path->Des() );

    iOwner.AppendRoot( ptr );

    ptr.Append( iDirectory );

    ptr.Append( KDirectorySeparator );    

    return path;

    }