// Copyright (c) 2002-2009 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:
// $Header$
// CCmdLog.cpp
// rev:	mjdavey, symbian@mjdss.com, July 2002
// for:	Typhoon (7.0s) & JetStream (8.0)
// This module implements the CLogFile class
// Include Files  
// 
//

#include <e32std.h>                     //
#include <s32file.h>                    //
#include <f32file.h>                    //
#include <e32hal.h>                     //
#include <fbs.h>                        //

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

#include "CLogFile.h"                    // This module

//-----------------------------------------------------------------------------
// End-of-line

_LIT8(KEndOfLine8,"\r\n");
_LIT (KEndOfLine ,"\r\n");

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

void TLogFileOverflow::Overflow( TDes16& aDes )
{
_LIT(KErrOverflowMsg, "...");
if( aDes.MaxLength() >= KErrOverflowMsg().Length() + aDes.Length() )
	aDes.Append(KErrOverflowMsg);
}

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

CLogFile *CLogFile::NewL( TInt aMaxLength )
{
CLogFile* self = NewLC( aMaxLength );
CleanupStack::Pop();
return self; 
}

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

CLogFile* CLogFile::NewLC( TInt aMaxLength )
{
CLogFile* self = new (ELeave) CLogFile();
CleanupStack::PushL(self);
self->ConstructL( aMaxLength );
return self;
}

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

CLogFile::~CLogFile( )
{
Close();
delete iBuffer;
iBuffer = NULL;
}

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

void CLogFile::ConstructL( TInt aMaxLength )
{
iIsOpen = EFalse;
iError = KErrNone;
iFileName.Zero();
iBufLength = aMaxLength;
iBuffer = NULL;
}

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

TInt CLogFile::Open( const TDesC& aFileName )
{
iError = KErrNone;
if ( IsOpen() )
	DoClose( );

iFileName.Copy( aFileName );
iError = DoOpen();

return iError;
}

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

TInt CLogFile::Open( )
{
iError = (!IsOpen()) ? DoOpen() : KErrNone;
return iError;
}

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

void CLogFile::Close( )
{
if ( IsOpen() ) 
	DoClose();

delete iBuffer;
iBuffer = NULL;
}

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

TBool CLogFile::IsOpen( )
{
return iIsOpen;
}

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

TPtrC CLogFile::FileName( ) const
{
TPtrC filename( iFileName );
return filename;
}

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

TInt CLogFile::Error( )
{
return iError;
}

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

void CLogFile::PrintHeading( )
{
iError = KErrNone;
if ( IsOpen() )
	{
	iError = DoHeading();
	(void)DoFlush();
	}
}

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

void CLogFile::Write( const TDesC& aText )
{
iError = KErrNone;
if ( IsOpen() )
	{
	iError = DoWrite( aText );
	(void)DoFlush();
	}
}

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

void CLogFile::Writeln( const TDesC& aText )
{
iError = KErrNone;
if ( IsOpen() )
	{
	iError = DoWrite( aText );
	(void)DoWrite( KEndOfLine8 );
	(void)DoFlush();
	}
}

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

void CLogFile::Writeln( )
{
iError = (IsOpen()) ? DoWrite( KEndOfLine8 ) : KErrNone;
}

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

void CLogFile::Printf( TRefByValue<const TDesC> aFmt, ... )
{
VA_LIST list;
VA_START(list, aFmt);
Printf(aFmt, list);
}

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

void CLogFile::Printf(TRefByValue<const TDesC> aFmt, VA_LIST& aList)
{
iError = KErrNone;
if (IsOpen())
	{
	iError = DoWrite(aFmt, aList);
	(void)DoFlush();
	}
}

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

TInt CLogFile::DoOpen ( )
{
// Allocate the formatting buffer if there is none so far.
if ( iBuffer == NULL ) 
	iBuffer = HBufC::New( iBufLength );

if ( iBuffer == NULL ) 
	return KErrNoMemory;

// Connect file server.
TInt ret = KErrNone;
if ( ret = iFs.Connect(), ret != KErrNone )
	return ret;

// Open/Create the file. Notice, that this does not create the log
// directory i.e. the directory must have been created in advance.
TUint mode = EFileStreamText|EFileWrite|EFileShareAny;
if ( ret = iFile.Open( iFs, iFileName, mode ), ret == KErrNotFound )
	// Create the file since it wasn't there.
	ret = iFile.Create( iFs, iFileName, mode );

if ( ret != KErrNone )
	{
	iFs.Close();
	return ret;
	}

// Seek to the end; error in seek is not recorded.
TInt filepos;
(void)iFile.Seek( ESeekEnd, filepos );

// Mark the file open and return.
iIsOpen = ETrue;
return ret;
}

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

void CLogFile::DoClose( )
{
iFile.Close();
iFs.Close();
iIsOpen = EFalse;
}

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

TInt CLogFile::DoFlush( )
{
return iFile.Flush();
}

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

TInt CLogFile::DoHeading( )
{
// Make a temporary buffer to format the date and time and format.
HBufC* buf = HBufC::New( 80 );
if ( buf == NULL ) 
	return KErrNoMemory;

TPtr timebuf = buf->Des();
TPtr buffer  = iBuffer->Des();
TTime time;
time.HomeTime();
TInt ret = KErrNone;
TRAP(ret, time.FormatL( timebuf, _L("%H:%T:%S on %E, %F%D-%*M-%Y")) );
if ( ret == KErrNone )
	// Then format the standard header (file name and date/time). An
	// overflow in here does not cause panic I hope.
	TRAP(	ret, 
				buffer.AppendFormat( _L("%S%S - %S%S%S"), 
				&iOverflow,
				&KEndOfLine, 
				&iFileName, 
				&timebuf, 
				&KEndOfLine, 
				&KEndOfLine )
				);

// Delete the temporary buffer and if formatting went ok, write.
delete buf;

if ( ret == KErrNone ) 
	ret = DoWrite( buffer );
return ret;
}

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

TInt CLogFile::DoWrite(TRefByValue<const TDesC> aFmt, VA_LIST& aList)
{
// Format to the buffer and write. Overflow in formatting is captured
// in order to not cause any panic.
TPtr buffer = iBuffer->Des();
buffer.Zero();
TInt ret = KErrNone;
TRAP(ret, buffer.AppendFormatList(aFmt, aList, &iOverflow));
if (ret == KErrNone) 
	ret = DoWrite(buffer);
return ret;
}

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

TInt CLogFile::DoWrite( const TDesC&  aText )
{
#ifndef _UNICODE

// Just write as such.
return iFile.Write ( aText );

#else

// Convert to 8-bit and write. Every write allocates a temporary buffer
// from heap and that buffer is allocated long enough to write the text
// as the whole.
HBufC8* buf8 = HBufC8::New( aText.Length() );
if ( buf8 == NULL ) 
	return KErrNoMemory;
TPtr8 ptr8 = buf8->Des();
ptr8.Copy( aText );
TInt ret = iFile.Write( ptr8 );

delete buf8;
return ret;

#endif // _UNICODE
}

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

#ifdef _UNICODE

TInt CLogFile::DoWrite( const TDesC8& aText )
{
return iFile.Write( aText );
}

#endif // _UNICODE

//-----------------------------------------------------------------------------
//  End of File  
//-----------------------------------------------------------------------------