/*
* Copyright (c) 2006-2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:   Writes IBY files
*
*/



#include <f32file.h>
#include <bautils.h>
#include <utf.h>

#include "cbsibywriter.h"
#include "bsimportconstants.h"
//#include "importlogwriter.h"
#include "DebugTrace.h"

// CONSTANTS
_LIT8( KIBYHeader1,           "\n#ifndef __BRAND_" );
_LIT8( KIBYHeader2,           "\n#define __BRAND_" );
_LIT8( KIBYHeaderEnd,         "_IBY_" );
_LIT8( KIBYFileItem,          "\nfile=" );
_LIT8( KIBYEmptyLine,         "\n" );
_LIT8( KIBYSpace,             " \t\t " );
_LIT8( KIBYFooter,            "\n#endif //__BRAND_" );

// File & dir
_LIT8( KIBYBaseSource,        "\\epoc32\\winscw\\c" );

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

// ---------------------------------------------------------------------------
// CBSIBYWriter::NewL
// ---------------------------------------------------------------------------
//
CBSIBYWriter* CBSIBYWriter::NewL()
    {
    CBSIBYWriter* self = NewLC();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::NewLC
// ---------------------------------------------------------------------------
//
CBSIBYWriter* CBSIBYWriter::NewLC()
    {
    CBSIBYWriter* self = new (ELeave) CBSIBYWriter();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::ConstructL
// ---------------------------------------------------------------------------
//
void CBSIBYWriter::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::CBSIBYWriter
// ---------------------------------------------------------------------------
//
CBSIBYWriter::CBSIBYWriter()
    {
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::~CBSIBYWriter
// ---------------------------------------------------------------------------
//
CBSIBYWriter::~CBSIBYWriter()
    {
    iSourcePath.ResetAndDestroy();
    iSourceFiles.ResetAndDestroy();
    iDestinations.ResetAndDestroy();
    delete iIbyFile;
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::SetFileItemL
// ---------------------------------------------------------------------------
//
void CBSIBYWriter::SetFileItemL( const TDesC& aSrc, const TDesC& aDest )
    {
    TRACE( T_LIT( "CBSIBYWriter::SetFileItemL begin") );
    // Parse and construct filenames
    TParse srcparse;
    srcparse.Set( aSrc, NULL, NULL );

    TParse dstparse;
    dstparse.Set( aDest, NULL, NULL );

    // Path
    HBufC8* srcpath = HBufC8::NewLC( srcparse.Path().Length() );
    TPtr8 ptr( srcpath->Des() );
    CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr, srcparse.Path() );

    HBufC8* src = HBufC8::NewLC( srcparse.NameAndExt().Length() );
    ptr.Set( src->Des() );
    CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr, srcparse.NameAndExt() );

    HBufC8* dst = HBufC8::NewLC( aDest.Length() );
    ptr.Set( dst->Des() );
    
    HBufC* newDst = HBufC::NewLC( aDest.Length() );
    TPtr dstPtr( newDst->Des() );
    TPtrC name = dstparse.NameAndExt();
	TPtrC path = dstparse.Path();
	dstPtr.Append( KBSZDrive );
	dstPtr.Append( path );
	dstPtr.Append( name );
	
    CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr, dstPtr );
    
    TRACE( T_LIT( "CBSIBYWriter::SetFileItemL - setting source file %S"), &aSrc );
    TRACE( T_LIT( "CBSIBYWriter::SetFileItemL - setting destination file %S"), newDst );
	CleanupStack::PopAndDestroy( newDst );
    CleanupStack::Pop( 3 );

    // Append filepair
    iSourcePath.Append( srcpath );
    iSourceFiles.Append( src );
    iDestinations.Append( dst );
    
    TRACE( T_LIT( "CBSIBYWriter::SetFileItemL end") );
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::WriteIBYFile()
// ---------------------------------------------------------------------------
//
void CBSIBYWriter::WriteIBYFileL( RFs& aFs, const TDesC& aFileName )
    {
	TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL begin") );
	
    TInt count = iSourceFiles.Count();
    if( count == 0 )
    	{
    	TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL - No file elements, nothing to do.") );
    	return;
    	}
    if( count != iDestinations.Count() )
        {
		TRACE( T_LIT("Internal error: IBY filename count mismatch ( %d != %d )"),
            count, iDestinations.Count() );
        User::Leave( KErrCorrupt );
        }

	RFile outfile;
	TInt err = outfile.Open( aFs, aFileName, EFileWrite );
	if( err == KErrNotFound )
		{
		TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL - IBY file not initialized!") );
		// if the file is not initialized -> not ready
		err = KErrNotReady;
		}
	User::LeaveIfError( err );

    // write data
    TInt size = -1;
    User::LeaveIfError( outfile.Size( size ) );

    outfile.Write( size, KIBYEmptyLine );
    
	TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL - start writing files to IBY") );
    
    for( TInt i = 0; i < count; i++ )
        {
        outfile.Write( KIBYFileItem );
        outfile.Write( KIBYBaseSource );
        outfile.Write( iSourcePath[i]->Des() );
        outfile.Write( iSourceFiles[i]->Des() );
        outfile.Write( KIBYSpace );
        outfile.Write( iDestinations[i]->Des() );
        TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL - %S"), iDestinations[i] );
        }

	TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL - writing IBY file footer") );
    outfile.Write( KIBYEmptyLine );
    outfile.Write( KIBYFooter );
    outfile.Write( KIBYHeaderEnd );

    // cleanup
    outfile.Close();
    TRACE( T_LIT( "CBSIBYWriter::WriteIBYFileL end") );
    }

// ---------------------------------------------------------------------------
// CBSIBYWriter::WriteIBYFile()
// ---------------------------------------------------------------------------
//
void CBSIBYWriter::InitIbyFileL( RFs& aFs, const TDesC& aFileName )
	{
	TRACE( T_LIT( "CBSIBYWriter::InitIbyFileL begin") );
	HBufC* temp = aFileName.AllocL();
	delete iIbyFile;
	iIbyFile = temp;

    TInt err = aFs.MkDir( KBSIbyDirectory );
    if( err == KErrAlreadyExists )
    	{
    	err = KErrNone;
    	}
    User::LeaveIfError( err );
	
	TRACE( T_LIT( "CBSIBYWriter::InitIbyFileL IBY directory (%S) created"), &KBSIbyDirectory() );
	
	// Open file for writing
	RFile outfile;
    User::LeaveIfError( outfile.Replace( aFs, aFileName, EFileWrite ) );
    
    TRACE( T_LIT( "CBSIBYWriter::InitIbyFileL IBY file (%S) created"), &aFileName );
    
    outfile.Write( KIBYHeader1 );
    outfile.Write( KIBYHeaderEnd );
    outfile.Write( KIBYHeader2 );
    outfile.Write( KIBYHeaderEnd );
    outfile.Close();
    TRACE( T_LIT( "CBSIBYWriter::InitIbyFileL end") );
	}
// End of file