/*
* Copyright (c) 2003-2005 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:  Implementation of alternator.
*
*/



// INCLUDE FILES
#include "CAlternatorImp.h"
#include "ChatDebugPrint.h"
#include "CCABrandInstallerImp.h"
#include <eikenv.h>
#include <bautils.h>
#include <s32strm.h>	// load/save 
#include <s32file.h>
#include <eikapp.h>
#include <bautils.h>
#include <bldvariant.hrh>
#include <e32std.h>
#include <badesca.h>


// CONSTANTS
_LIT( KRsc, ".RSC" );
_LIT( KRscWild, ".R*" );
_LIT( KDirSeparator, "\\" );
_LIT( KRelativeBrandPath, "branding\\" );

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


// -----------------------------------------------------------------------------
// CAlternatorImp::CAlternatorImp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CAlternatorImp::CAlternatorImp()
//	:iResFiles( 1 )	// usually just one,
    {
    }

// -----------------------------------------------------------------------------
// CAlternatorImp::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CAlternatorImp::ConstructL( const TDesC& aBrandRoot )
    {
    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::ConstructL brand root is:%S" ) ,
             &aBrandRoot );
    iBrandRoot = HBufC::NewL( KMaxPath );
    TPtr myPtr = iBrandRoot->Des();
    myPtr = aBrandRoot;

    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::ConstructL ourbrand root is:%S" ),
             &myPtr );

    iEikEnv = CEikonEnv::Static();

    //Start procedure to install sis installed brands
    iBrandInstaller = CCABrandInstallerImp::NewL();
    if ( !( iBrandInstaller->ImportFolderExistsL() ) )
        {
        iBrandInstaller->CreateImportFolderL();
        }
    if ( iBrandInstaller->IsNewBrandAvailableL() )
        {
        iBrandInstaller->InstallNewBrandL();
        }
    }

// -----------------------------------------------------------------------------
// CAlternatorImp::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//

CAlternatorImp* CAlternatorImp::NewL( const TDesC& aBrandRoot )
    {
    CAlternatorImp* self = new( ELeave ) CAlternatorImp();

    CleanupStack::PushL( self );
    self->ConstructL(  aBrandRoot );
    CleanupStack::Pop( self );

    return self;
    }

// Destructor
CAlternatorImp::~CAlternatorImp()
    {
    delete iBrandRoot;
    delete iBrandInstaller;
    }


// constructs current bitmap file full path
const TDesC& CAlternatorImp::CurrentBitmapFileL( const TDesC& aModuleId,
                                                 const TDesC& aAlternative,
                                                 const TDesC& aBitmapFileName )
    {
    // if the path is not ok, set bitmap path as empty
    TInt ret( ConstructCompletePathAndCheck( iCurrentBitmap, aModuleId,
                                             aAlternative,
                                             aBitmapFileName ) );
    if ( ret != KErrNone )
        {
        if ( ret == KErrNoMemory )
            {
            User::Leave( ret );
            }
        iCurrentBitmap.Zero();
        }
    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::CurrentBitmapFileL :%S" ),
             &iCurrentBitmap );

    return iCurrentBitmap;
    }


// changes resource
TInt CAlternatorImp::ChangeResourceL( const TDesC& aModuleId,
                                      const TDesC& aAlternative,
                                      const TDesC& aResFileName,
                                      TInt& aResOffset  )
    {
    TInt err = LoadResourceFileL( aModuleId, aAlternative, aResFileName,
                                  aResOffset );
    return err;
    }

// changes bitmap file
TInt CAlternatorImp::ChangeBitmapFileL( const TDesC& aModuleId,
                                        const TDesC& aAlternative,
                                        const TDesC& aBitmapFileName )
    {
    // iCurrentBitmap contains the path if ok
    iCurrentBitmap.Zero();
    TInt ret( ConstructCompletePathAndCheck( iCurrentBitmap, aModuleId,
                                             aAlternative, aBitmapFileName ) );
    if ( ret == KErrNoMemory )
        {
        User::Leave( ret );
        }
    if ( ret != KErrNone )
        {
        return KErrNotFound;
        }
    // the new bitmap path is in iCurrentBitmap
    return KErrNone;
    }

void  CAlternatorImp::GetCurrentResourceFileL( const TDesC& aModuleId,
                                               const TDesC& aAlternative,
                                               const TDesC& aResFileName,
                                               TDes& aFullPath )
    {
    TInt ret( ConstructCompletePathAndCheck( aFullPath, aModuleId,
                                             aAlternative, aResFileName ) );
    if ( ret == KErrNoMemory )
        {
        User::Leave( ret );
        }
    if ( ret != KErrNone )
        {
        aFullPath.Zero();
        }

    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::GetCurrentResourceFileL :%S" ),
             &aFullPath );

    // otherwise the current resource file path is in aFullPath
    }

void CAlternatorImp::SetBrandRoot( const TDesC& aBrandRoot )
    {
    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::SetBrandRoot %S" ), &aBrandRoot );

    TPtr myPtr = iBrandRoot->Des();
    myPtr = aBrandRoot;
    }

// loads resource file
TInt CAlternatorImp::LoadResourceFileL( const TDesC& aModuleId,
                                        const TDesC& aAlternative,
                                        const TDesC& aResFileName,
                                        TInt& aResOffSet )
    {

    TFileName resFilePath;
    TInt ret( ConstructCompletePathAndCheck( resFilePath, aModuleId,
                                             aAlternative, aResFileName ) );
    if ( ret == KErrNoMemory )
        {
        User::Leave( ret );
        }
    if ( ret != KErrNone )
        {
#ifdef _DEBUG
        RDebug::Print( _L( "path not found" ) );
#endif
        return KErrNotFound;
        }

    TEntry entry;
    User::LeaveIfError( iEikEnv->FsSession().Entry( resFilePath, entry ) );
    TInt fileSize( entry.iSize );
    // test if there's enough heap available, this one leaves if not and
    // resources won't get changed
    HBufC8* allocTest = HBufC8::NewL( fileSize );
    delete allocTest;


    // if path ok, then make the change, first delete the previous one
    iEikEnv->DeleteResourceFile( aResOffSet );

    RFs& fs = iEikEnv->FsSession();

    if ( resFilePath.Length() != 0 )
        {
        BaflUtils::NearestLanguageFile( fs, resFilePath );
        }

    TRAPD( err, aResOffSet =  iEikEnv->AddResourceFileL( resFilePath )  );
    if ( err == KErrNoMemory )
        {
        User::Leave( KErrNoMemory );
        }


#ifdef _DEBUG
    RDebug::Print( _L( "ADDED resource file:" ) );
    RDebug::Print( resFilePath );
#endif

    return err;
    }


TBool CAlternatorImp::IsPathOk( const TDesC& aCheckThis ) const
    {
    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::IsPathOk %S" ), &aCheckThis );

    return BaflUtils::FileExists( iEikEnv->FsSession(), aCheckThis );
    }

TInt CAlternatorImp::ConstructCompletePathAndCheck( TDes& aResult,
                                                    const TDesC& aModuleId,
                                                    const TDesC& aAlternative,
                                                    const TDesC& aFileName )
    {
    aResult.Zero();
    aResult.Append( *iBrandRoot );

    aResult.Append( KRelativeBrandPath() );
    aResult.Append( aModuleId );
    aResult.Append( KDirSeparator );
    aResult.Append( aAlternative );
    aResult.Append( KDirSeparator );

    TBool resourceFile( EFalse );
    TFileName file( aFileName );

    TInt rscPos( aFileName.FindC( KRsc ) );
    if ( rscPos != KErrNotFound )
        {
        // replace the ".RSC" with ".R*"
        file.Copy( aFileName.Left( rscPos ) );
        file.Append( KRscWild );
        resourceFile = ETrue;
        }
    else
        {
        file.Copy( aFileName );
        }

    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::ConstructCompletePathAndCheck \
                          trying to find %S%S" )
             , &aResult, &file );

    // Find the actual file
    CDir* files = NULL;
    TFindFile fileFinder( iEikEnv->FsSession() );
    TInt err( fileFinder.FindWildByDir( file, aResult, files ) );
    delete files;

    // If file was found, then take the first appearance of it
    // (order is correct aready)
    if ( err == KErrNone )
        {
        aResult.Zero();
        if ( resourceFile )
            {
            // change the ".R*" back to ".RSC"
            TParsePtrC parse( fileFinder.File() );
            file.Copy( parse.DriveAndPath() );
            file.Append( parse.Name() );
            file.Append( KRsc );

            CHAT_DP( D_CHAT_LIT( "CAlternatorImp::ConstructCompletePathAndCheck \
    		                      finding nearest language file for %S" ), &file );

            if ( file.Length() != 0 )
                {
                BaflUtils::NearestLanguageFile( iEikEnv->FsSession(), file );
                }

            aResult.Copy( file );
            }
        else
            {
            aResult.Append( fileFinder.File() );
            }
        }

    CHAT_DP( D_CHAT_LIT( "CAlternatorImp::ConstructCompletePathAndCheck \
                          TFindFile returned %d for %S" ),
             err, &aResult );

    // return was the file found or not
    return err;
    }

//  End of File