/*

* 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 <bamdesca.h>

#include "ncdstorageclientimpl.h"

#include <f32file.h>

#include <bautils.h>

#include <badesca.h>

#include <s32file.h>

#include "ncdstorageimpl.h"

#include "ncdstoragemanagerimpl.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

_LIT( KNamespaceFile, "namespaces" );

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

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

// ConstructL

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

//

void CNcdStorageClient::ConstructL( const TDesC& aUid )

    {

    DLTRACEIN( ("") );

    // Copy the uid

    iUid.CreateL( aUid );

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL( KMaxPath );

    // Create the path string for the storage    

    AppendRoot( path );

    // Create the directory

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

    // Create storages for each found directory

    //CreateStoragesFromFileSystemL( path );      

    CleanupStack::PopAndDestroy( &path );

    // Read namespaces and create storages

    TRAPD( err, ReadNamespacesL() );

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

        {

        User::Leave( err );

        }

    DLTRACEOUT( ("") );

    }

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

// NewL

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

//

CNcdStorageClient* CNcdStorageClient::NewL( MNcdStorageOwner& aOwner,

    const TDesC& aUid )

    {

    CNcdStorageClient* self = CNcdStorageClient::NewLC( aOwner, aUid );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CNcdStorageClient* CNcdStorageClient::NewLC( MNcdStorageOwner& aOwner,

    const TDesC& aUid )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aUid );    

    return self;

    }

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

// Destructor

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

//

CNcdStorageClient::~CNcdStorageClient()

    {

    iUid.Close();

    iStorages.ResetAndDestroy();

    }

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

// Storage creator

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

//

MNcdStorage& CNcdStorageClient::CreateStorageL( const TDesC& aNamespace )

    {

    DLTRACEIN( ("") );

    TInt index = FindStorageByNamespace( aNamespace );

    if ( index != KErrNotFound ) 

        {

        return *( iStorages[ index ] );

        }

    CNcdStorage* storage = CNcdStorage::NewLC( *this, aNamespace );

    iStorages.AppendL( storage );

    CleanupStack::Pop( storage );

    // Save namespaces

    SaveNamespacesL();

    return *static_cast<MNcdStorage*>( storage );

    }

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

// Storage getter

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

//

MNcdStorage& CNcdStorageClient::StorageL( const TDesC& aNamespace )

    {

    DLTRACEIN(( _L("NS: %S"), &aNamespace ));

    TInt index = FindStorageByNamespace( aNamespace );

    User::LeaveIfError( index );

    DLTRACEOUT(("index: %d", index));

    return *(iStorages[index]);

    }

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

// Storage remover

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

//

void CNcdStorageClient::RemoveStorageL( const TDesC& aNamespace )

    {

    DLTRACEIN((""));

    if ( !aNamespace.Length() ) 

        {

        User::Leave( KErrArgument );

        }

    TInt index = FindStorageByNamespace( aNamespace );

    if ( index == KErrNotFound )

        {

        DLTRACEOUT(("Namespace not found"));

        return;

        }

    // Generate path before deleting the storage in case aNamespace is a

    // reference to storage's member variable

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL( KMaxPath );

    // Generate path to the storage directory

    AppendRoot( path );

    path.Append( iStorages[ index ]->Directory() );

    path.Append( KDirectorySeparator );

    delete iStorages[ index ];

    iStorages.Remove( index );

    DLTRACE( ( _L("Deleting: %S"), &path ) );

    CNcdStorageManager::RemoveDirectoryL( FileSession(), 

        path );

    CleanupStack::PopAndDestroy( &path );

    // Updates the list of namespaces

    SaveNamespacesL();

    DLTRACEOUT( ("") );

    }

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

// Path generator

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

//    

void CNcdStorageClient::AppendRoot( TDes& aDes ) const

    {

    DLTRACEIN((""));

    iOwner.AppendRoot( aDes );        

    aDes.Append( iUid );

    aDes.Append( KDirectorySeparator );

    DLTRACEOUT((""));

    }

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

// File session getter

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

//    

RFs& CNcdStorageClient::FileSession()

    {

    DLTRACEIN((""));

    return iOwner.FileSession();

    }

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

// File manager getter

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

//    

CFileMan& CNcdStorageClient::FileManager()

    {

    return iOwner.FileManager();

    }

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

// Client UID getter

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

//

const TDesC& CNcdStorageClient::ClientUid() const

    {

    return iUid;

    }

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

// NamespacesL

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

//

MDesCArray* CNcdStorageClient::NamespacesLC() const

    {

    DLTRACEIN((""));

    CPtrCArray* array = new(ELeave) CPtrCArray( KListGranularity );

    // Casting ensures that the popped pointer matches the returned pointer

    CleanupDeletePushL( static_cast<MDesCArray*>( array) );

    array->SetReserveL( iStorages.Count() );

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

        {

        array->AppendL( iStorages[i]->Namespace() );

        }

    return array;

    }

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

// Constructor

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

//

CNcdStorageClient::CNcdStorageClient( MNcdStorageOwner& aOwner ) : 

    iOwner( aOwner )

    {

    }    

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

// Searches for a storage that matches the given namespace

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

//        

TInt CNcdStorageClient::FindStorageByNamespace( 

    const TDesC& aNamespace ) const

    {

    TInt count = iStorages.Count();

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

        {

        if ( iStorages[ i ]->Namespace().Compare( aNamespace ) == 0) 

            {

            return i;

            }            

        }

    return KErrNotFound;

    }

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

// Creates a storage object for each found directory

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

//    

/*    

void CNcdStorageClient::CreateStoragesFromFileSystemL( const TDesC& aPath )

    {

    DLTRACEIN((""));

    CDir* dirList = NULL;

    CDir* fileList = NULL;

    User::LeaveIfError( FileSession().GetDir( aPath, 

        KEntryAttNormal, ESortByName, fileList, dirList ) );

    DLTRACE(("Creating storages"));

    TInt err = KErrNone;

    // No need for this

    delete fileList;

    CleanupStack::PushL( dirList );

    for ( TInt i = 0; i < dirList->Count(); ++i )

        {

        TRAP( err, CreateStorageL( (*dirList)[i].iName ) );

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

            {

            User::Leave( err );

            }

        }

    CleanupStack::PopAndDestroy( dirList );    

    }

*/

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

// Reads namespace encodings from the namespace file

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

//

void CNcdStorageClient::ReadNamespacesL()

    {

    DLTRACEIN((""));    

    RBuf filename;

    CleanupClosePushL( filename );

    filename.CreateL( KMaxPath );

    AppendRoot( filename );

    filename.Append( KNamespaceFile );

    HBufC8* data = ReadFileL( FileSession(), filename );

    CleanupStack::PopAndDestroy( &filename );

    CleanupStack::PushL( data );

    RDesReadStream reader( *data );

    CleanupClosePushL( reader );

    // number of namespaces

    TInt32 count = reader.ReadInt32L();

    iStorages.ReserveL( count );

    HBufC* namesp = NULL;

    HBufC* dir = NULL;

    DLINFO(("Internalizing %d namespaces"));

    while ( count )

        {       

        DLTRACE(("Internalizing namespace and directory")); 

        InternalizeDesL( namesp, reader );                

        CleanupStack::PushL( namesp );

        InternalizeDesL( dir, reader );

        CleanupStack::PushL( dir );

        TBool exists = DirectoryExistsL( *dir );

        if ( exists ) 

            {

            DLTRACE(( _L("Client nsp: %S in dir: %S"),

                namesp, dir ));

            // Ownership of the namesp and dir is transferred

            CNcdStorage* client = CNcdStorage::NewL(

                *this, namesp, dir );

            CleanupStack::Pop( 2, namesp ); // dir, namesp

            // Won't fail because of the ReserveL-call

            iStorages.Append( client );            

            DLTRACE(("Client created successfully"));

            }

        else

            {

            DLTRACE(("Client doesn't exist anymore"));

            CleanupStack::PopAndDestroy( 2, namesp ); // dir, namesp

            }

        namesp = NULL;

        dir = NULL;

        --count;

        }

    CleanupStack::PopAndDestroy( 2, data ); // reader, data

    }

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

// Save namespaces

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

//

void CNcdStorageClient::SaveNamespacesL()

    {

    DLTRACEIN((""));

    TFileName tempName;

    // Get root dir

    RBuf target;

    CleanupClosePushL( target );

    target.CreateL( KMaxPath );

    AppendRoot( target );

    DLINFO(( "Creating file write stream.." ));

    RFileWriteStream writer;

    CleanupClosePushL( writer );

    DLINFO(( "Getting file session.." ));

    RFs& fs( FileSession() );

    // Create a temp file

    User::LeaveIfError( writer.Temp( 

        fs, 

        target, 

        tempName, 

        EFileWrite | EFileStream ) );

    writer.WriteInt32L( iStorages.Count() );

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

        {

        ExternalizeDesL( iStorages[i]->Namespace(), writer );

        ExternalizeDesL( iStorages[i]->Directory(), writer );

        }

    // Commit explicitly so we can react to errors

    writer.CommitL();

    CleanupStack::PopAndDestroy( &writer );

    // Append the namespace-file to root dir

    target.Append( KNamespaceFile );

    // Replace the old file with the new one

    BaflUtils::DeleteFile( fs, target );

    User::LeaveIfError( fs.Rename( tempName, target ) );

    CleanupStack::PopAndDestroy( &target ); // target

    DLTRACEOUT(("File saved successfully"));

    }

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

// Checks if the directory exists

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

//

TBool CNcdStorageClient::DirectoryExistsL( const TDesC& aDir )

    {

    DLTRACEIN(( _L("Directory: %S"), &aDir ));

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL( KMaxPath );

    AppendRoot( path );    

    path.Append( aDir );

    TBool exists = BaflUtils::FolderExists( FileSession(), path );

    CleanupStack::PopAndDestroy( &path );

    return exists;

    }