/*

* 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 "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:  Stores element data and writes it to stream

*

*/

#include <s32strm.h>

#include <s32file.h>

#include <f32file.h>

#include <bautils.h>

#include <utf.h>

#include "bsimportconstants.h"

#include "cbsstoragemanager.h"

#include "cbsstorage.h"

#ifdef __WINSCW__

#include "cbsibywriter.h"

#endif

#include "cbsserver.h"

#include "cbssession.h"

#include "mbsupdater.h"

//#include "importlogwriter.h"

#include "debugtrace.h"

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

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

// CBSStorageManager::NewL

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

//

CBSStorageManager* CBSStorageManager::NewL( CBSSession* aSession, const TDesC& aAppId )

    {

    CBSStorageManager* self = NewLC( aSession, aAppId );

    CleanupStack::Pop();

    return self;

    }

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

// CBSStorageManager::NewLC

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

//

CBSStorageManager* CBSStorageManager::NewLC( CBSSession* aSession, const TDesC& aAppId )

    {

    CBSStorageManager* self =

        new (ELeave) CBSStorageManager();

    CleanupStack::PushL( self );

    self->ConstructL( aSession, aAppId );

    return self;

    }

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

// CBSStorageManager::ConstructL

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

//

void CBSStorageManager::ConstructL( CBSSession* aSession, const TDesC& aAppId )

    {

    TRACE( T_LIT( "CBSStorageManager::ConstructL begin aAppId[%S]"), &aAppId );

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

// RFs::ShareProtected() needs to be called for the session 

// used to open the handle that is going to be shared.

// ShareProtected() was called to a wrong Fs-session in 

// CBSBrandHandler::GetFileL().

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

    iFs.CreatePrivatePath( EDriveC );

    iSession = aSession;

#ifdef __WINSCW__        

    if( !iWriter )

    	{

    	iWriter = CBSIBYWriter::NewL();

    	}

    if( aAppId.Compare( KNullDesC ) )

    	{

    	HBufC* temp = HBufC::NewL( KBSIbyDirectory().Length() +

    							   aAppId.Length() +

    							   KBSIbyExtension().Length() );

		TPtr ptr( temp->Des() );

		ptr.Append( KBSIbyDirectory );

		ptr.Append( aAppId );

		ptr.Append( KBSIbyExtension );

		delete iIbyFile;

		iIbyFile = temp;

	    iWriter->InitIbyFileL( iFs, *iIbyFile );

    	}

#endif

    TRACE( T_LIT( "CBSStorageManager::ConstructL end") );

    }

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

// CBSStorageManager::CBSStorageManager

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

//

CBSStorageManager::CBSStorageManager() :

    iCurrent( KErrNotFound )

    {

    }

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

// CBSStorageManager::~CBSStorageManager

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

//

CBSStorageManager::~CBSStorageManager()

    {

    TRACE( T_LIT( "CBSStorageManager::~CBSStorageManager begin") );

    iStorages.ResetAndDestroy();

    iFs.Close();

	delete iAppId;

	delete iBrandId;

	delete iLanguageId;

    delete iFilename;

    #ifdef __WINSCW__

    delete iWriter;

    #endif

    delete iIbyFile;

    TRACE( T_LIT( "CBSStorageManager::~CBSStorageManager end") );

    }

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

// CBSStorageManager::InitTransactionL

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

//

void CBSStorageManager::ConnectTransactionL(const TDesC& aAppId,

				    					  const TDesC& aBrandId,

				    					  TLanguage aLanguageId,

    					   				  TBool aAppending, /*= EFalse*/

    					   				  TInt aReserved /*=0*/)

	{

	TRACE( T_LIT( "CBSStorageManager::ConnectTransactionL begin AppId[%S],BrandId[%S]"),&aAppId, &aBrandId );

	if( iActive )

		{

		TBool transactionOk = ETrue;

		transactionOk = iReserved == aReserved;

		if( transactionOk )

			{

			transactionOk = iLanguageIdNum == aLanguageId;

			}

		if( transactionOk )

			{

			transactionOk != iAppId->Compare( aAppId );

			}

		if( transactionOk )

			{

			transactionOk != iBrandId->Compare( aBrandId );

			}

		if( !transactionOk )

			{

			User::Leave( KErrArgument );

			}

		// the same transaction as is ongoing

		return;

		}

	iActive = ETrue;

    HBufC* tmpAppId = aAppId.AllocL();

    delete iAppId;

    iAppId = tmpAppId;

    HBufC* tmpBrandId = aBrandId.AllocL();

    delete iBrandId;

    iBrandId = tmpBrandId;

    iLanguageIdNum = aLanguageId;

    TBuf<KLangBufLength> buffer;

    if( aLanguageId < 10 )

    	{

    	// we want two digit languageid

    	buffer.AppendNum( KLeadingZero );

    	}

    buffer.AppendNum( aLanguageId );

    HBufC* tmp = buffer.AllocL();

    delete iLanguageId;

    iLanguageId = tmp;

    iReserved = aReserved;

    HBufC* tempFile = ConstructFileNameL();

    delete iFilename;

    iFilename = tempFile;

    iAppending = aAppending;

	TRACE( T_LIT( "CBSStorageManager::ConnectTransactionL end") );

	}

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

// CBSStorageManager::CancelTransactionL

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

//

void CBSStorageManager::CancelTransactionL()

	{

	TRACE( T_LIT( "CBSStorageManager::CancelTransactionL begin") );

	if( !iActive )

		{

		User::Leave( KErrNotFound );

		}

	// this closes the transaction

	CleanupTransaction();

	TRACE( T_LIT( "CBSStorageManager::CancelTransactionL end") );

	}

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

// CBSStorageManager::ConstructFileNameL()

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

//

HBufC* CBSStorageManager::ConstructFileNameL( TInt aReserved /* = 0 */ )

    {

    HBufC* fileName = NULL;

    if( iAppId && iBrandId && iLanguageId )

        {

        fileName = ConstructFileNameL( *iAppId, *iBrandId, iLanguageIdNum, aReserved );

        }

    return fileName;

    }

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

// CBSStorageManager::ConstructFileNameL()

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

//

HBufC* CBSStorageManager::ConstructFileNameL( const TDesC& aAppId,

										      const TDesC& aBrandId,

										      TLanguage aLanguage,

										      TInt aReserved /* = 0 */ )

    {

	HBufC* fileName = NULL;

    TBuf<KLangBufLength> langBuf;

	if (aLanguage >= 100)

		User::LeaveIfError (KErrNotFound);

    if( aLanguage < 10 )

    	{

    	// we want two digit languageid

    	langBuf.AppendNum( KLeadingZero );

    	}

    langBuf.AppendNum( aLanguage );

    TInt length = aAppId.Length() + aBrandId.Length() +

                  KDefFileName().Length() + KDirSeparator().Length() * 2 +

                  langBuf.Length() + KDot().Length() * 3 + KMaxVersionLenght;

	fileName = HBufC::NewLC( length );

    TPtr file( fileName->Des() );

    // [application_id]\[brand_id]\[def_filename][language_id]

    //

    file.Append( aAppId );

    file.Append( KDirSeparator );

    file.Append( aBrandId );

    file.Append( KDirSeparator );

    iDir.Set( file.Left( file.Length() ) );

    file.Append( KDefFileName );

    file.Append( langBuf );

    if( aReserved > 0 )

    	{

	    TBuf<KMaxVersionLenght> versionBuffer;

	    versionBuffer.AppendNum( aReserved );

	    file.Append( KDot() );

    	file.Append( versionBuffer );

    	}

    if( fileName )

    	{

    	CleanupStack::Pop( fileName );

    	}

    return fileName;

    }

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

// CBSStorageManager::CreateStorageL

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

//

void CBSStorageManager::CreateStorageL()

    {

    CBSStorage* tmp = CBSStorage::NewL();

    iStorages.Append( tmp );

    iCurrent = iStorages.Find( tmp );

    }

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

// CBSStorageManager::StorageCount

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

//

TInt CBSStorageManager::StorageCount()

    {

    return iStorages.Count();

    }

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

// CBSStorageManager::Storage

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

//

CBSStorage* CBSStorageManager::Storage( TInt aIndex )

    {

    return iStorages[ aIndex ];

    }

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

// CBSStorageManager::Storage

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

//

CBSStorage* CBSStorageManager::Storage()

    {

    if( iStorages.Count() > 0 )

    	{

    	return iStorages[ iCurrent ];	

    	}

    return NULL;

    }

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

// CBSStorageManager::WriteStorageFilesL

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

//

TInt CBSStorageManager::WriteStorageFilesL()

    {

    TRACE( T_LIT( "CBSStorageManager::WriteStorageFilesL begin") );

    if( !iActive )

    	{

    	User::Leave( KErrNotFound );

    	}

    TInt count = iStorages.Count();

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

        {

        // get the private path

        TBuf<KMaxPath> path;

        User::LeaveIfError( iFs.PrivatePath( path ) );

        // construct absolute filename

        HBufC* fullname = FullFileNameLC( *iFilename, ETrue );

        TParse filestorename;

        iFs.Parse( *fullname, filestorename );

	    RFileWriteStream outstream;

		TInt currentVersion = iReserved;

		TInt newVersion = iReserved;

		// check if the brand has any active clients

		TBool brandActive = ETrue;

		if( iSession )

			{

			CBSServer* server = iSession->Server();

			if( server )

				{

				brandActive = server->MatchSessionL( *iAppId, *iBrandId,

													 iLanguageIdNum, iSession, currentVersion );					

				}

			}

		if( BaflUtils::FileExists( iFs, filestorename.FullName() ) )

			{

			currentVersion = ReadVersionL( filestorename.FullName() );

			if( iReserved == KBSAutomaticVersionUpdate && brandActive )

				{

				// the brand has active clients

				// check if there is already a versioned file for this version

				HBufC* fileName = FindAvailableVersionL( currentVersion + 1, newVersion );

				CleanupStack::PushL( fileName);

				HBufC* newName = FullFileNameLC( *fileName, ETrue );

		        iFs.Parse( *newName, filestorename );

				if( BaflUtils::FileExists( iFs, filestorename.FullName() ) )

					{

					// the file already exists

					User::Leave( KErrAlreadyExists );

					}

				CleanupStack::PopAndDestroy( 2, fileName ); // newName, fileName

				}

			else if( ( iReserved == currentVersion ) )

				{

				// this version is already installed

				User::Leave( KErrAlreadyExists );

				}

			else

				{

				// check if the current version brand is active

				brandActive = iSession->Server()->MatchSessionL( *iAppId, *iBrandId,

													 iLanguageIdNum, iSession, currentVersion );

				// new version

				if( brandActive )

					{

					// brand is active

					// check if there is already a versioned file for this version

					HBufC* fileName = ConstructFileNameL( iReserved );

					CleanupStack::PushL( fileName );

			        HBufC* newName = FullFileNameLC( *fileName, ETrue );

			        iFs.Parse( *newName, filestorename );

					if( BaflUtils::FileExists( iFs, filestorename.FullName() ) )

						{

						// the file already exists

						User::Leave( KErrAlreadyExists );

						}

					CleanupStack::PopAndDestroy( 2, fileName ); // newName, fileName

					}

				}

			}

		// write a new brand file

	    // Construct the output file & stream.

	    iFs.MkDirAll( filestorename.DriveAndPath() );

        TInt err = outstream.Replace( iFs, filestorename.FullName(), EFileWrite );

        if( err )

            {

			TRACE( T_LIT("ERROR: Cannot create branding file: '%S'"), fullname );

            User::Leave( err );

            }

        CleanupClosePushL( outstream );

		if( iReserved == KBSAutomaticVersionUpdate )

			{

			// set the next version

			iStorages[i]->SetVersion( newVersion );

			iReserved = newVersion;

			}

        // Write data to file

        TRAPD( extError, iStorages[i]->ExternalizeL( outstream ) );

		if( extError && !iAppending )

			{

			// there was an error externalizing the data and we are installing

			// delete the file, since it's not complete

			iFs.Delete( filestorename.DriveAndPath() );

			}

		User::LeaveIfError( extError );

#ifdef __WINSCW__

        // Add to IBY file

        iWriter->SetFileItemL( *fullname, *fullname );

#endif

        CleanupStack::PopAndDestroy( 2 ); // fullname, outstream

		// existing brand modified --> inform server 

		if( iSession )

			{

			CBSServer* server = iSession->Server();

			if( server )

				{

				server->BrandUpdatedL( *iAppId, *iBrandId,

									   iLanguageIdNum, iSession, iReserved );					

				}

			}

        }

    // this closes the transaction

	CleanupTransaction();

	TRACE( T_LIT( "CBSStorageManager::WriteStorageFilesL end") );

	return iReserved;

    }

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

// CBSStorageManager::ReadVersionL

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

//

TInt CBSStorageManager::ReadVersionL( const TDesC& aFilename )

	{

    RFile handle;

    User::LeaveIfError( handle.Open( iFs, aFilename, EFileRead ) );

    CleanupClosePushL( handle );

	RFileReadStream stream;

	stream.Attach( handle );

	CleanupClosePushL( stream );

	TInt version = stream.ReadInt16L();

	CleanupStack::PopAndDestroy( 2 ); // stream, handle

	return version;

	}

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

// CBSStorageManager::FindAvailableVersionL

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

//	

HBufC* CBSStorageManager::FindAvailableVersionL( TInt /*aCurrentVersion*/, TInt& aNewVersion )

	{

	HBufC* fileName =  NULL;

	TInt newVersion = GetNewestVersionL( *iAppId, *iBrandId, iLanguageIdNum );

	aNewVersion = newVersion++;

	fileName = ConstructFileNameL( aNewVersion );

	return fileName;

	}