/** @file
* Copyright (c) 2007 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:  Represents one downloadable file
*
*/


// User include files
#include "httpfile.h"

// Constants
_LIT(KUnderScore, "_");
const TUint KMaxSameFileNames = 1000;
const TUint KSpaceForNumber = 5; // underscore + 4 digits
const TUint KFinishFileCreationLoop = 1001;

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

// --------------------------------------------------------------------------
// CHttpFile::CHttpFile()
// --------------------------------------------------------------------------
//
CHttpFile::CHttpFile( TAny* aKey )
    {
    iKey = aKey;
    iPath = NULL;
    }

// --------------------------------------------------------------------------
// CHttpFile::CHttpFile()
// --------------------------------------------------------------------------
//
CHttpFile::CHttpFile( TAny* aKey, const RFile& aFileHandle )
    {
    iKey = aKey;
    iPath = NULL;
    iFile.Duplicate( aFileHandle );
    }

// --------------------------------------------------------------------------
// CHttpFile::ConstructL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::ConstructL( const TDesC8& aUri, const TDesC& aPath )
    {
    SetUriL( aUri );

    iPath = aPath.AllocL();
    
    User::LeaveIfError( iFsSession.Connect() );
    }

// --------------------------------------------------------------------------
// CHttpFile::ConstructL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::ConstructL( const TDesC8& aUri )
    {
    SetUriL( aUri );
    }
// --------------------------------------------------------------------------
// CHttpFile::NewL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
CHttpFile* CHttpFile::NewL( TAny* aKey, 
                            const TDesC8& aUri, 
                            const TDesC& aPath )
    {
    CHttpFile* self = CHttpFile::NewLC( aKey, aUri, aPath );
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CHttpFile::NewLC()
// (See comments in header file)
// --------------------------------------------------------------------------
//
CHttpFile* CHttpFile::NewLC( TAny* aKey, 
                             const TDesC8& aUri, 
                             const TDesC& aPath )
    {
    CHttpFile* self = new( ELeave ) CHttpFile( aKey );
    CleanupStack::PushL( self );
    self->ConstructL( aUri, aPath );
    return self;
    }

// --------------------------------------------------------------------------
// CHttpFile::NewL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
CHttpFile* CHttpFile::NewL( TAny* aKey, const TDesC8& aUri,
                            const RFile& aFileHandle )
    {
    CHttpFile* self = CHttpFile::NewLC( aKey, aUri, aFileHandle );
    CleanupStack::Pop( self );
    return self;
    }

// --------------------------------------------------------------------------
// CHttpFile::NewLC()
// (See comments in header file)
// --------------------------------------------------------------------------
//
CHttpFile* CHttpFile::NewLC( TAny* aKey, const TDesC8& aUri, 
                             const RFile& aFileHandle )
    {
    CHttpFile* self = new( ELeave ) CHttpFile( aKey, aFileHandle );
    CleanupStack::PushL( self );
    self->ConstructL( aUri );
    return self;
    }

// --------------------------------------------------------------------------
// CHttpFile::~CHttpFile()
// (See comments in header file)
// --------------------------------------------------------------------------
//
CHttpFile::~CHttpFile()
    {
    iFile.Close();
    delete iUri;
    delete iPath;
    iHeaderArray.ResetAndDestroy();

    iFsSession.Close();
    }

// --------------------------------------------------------------------------
// CHttpFile::TrackProgress()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::TrackProgress( TBool aValue ) 
    {
    iTrackProgress = aValue;
    }

// --------------------------------------------------------------------------
// CHttpFile::TrackingOn()
// (See comments in header file)
// --------------------------------------------------------------------------
//
TBool CHttpFile::TrackingOn() const
    {
    return iTrackProgress;    
    }

// --------------------------------------------------------------------------
// CHttpFile::Key()
// (See comments in header file)
// --------------------------------------------------------------------------
//
TAny* CHttpFile::Key() const
    {
    return iKey;
    }

// --------------------------------------------------------------------------
// CHttpFile::Uri()
// (See comments in header file)
// --------------------------------------------------------------------------
//
const HBufC8* CHttpFile::Uri() const
    {
    return iUri;
    }

// --------------------------------------------------------------------------
// CHttpFile::SetUriL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::SetUriL( const TDesC8& aUri )
    {
    HBufC8* uri = aUri.AllocL();
    delete iUri;
    iUri = uri;
    }

// --------------------------------------------------------------------------
// CHttpFile::Path()
// (See comments in header file)
// --------------------------------------------------------------------------
//
const HBufC* CHttpFile::Path() const
    {
    return iPath;
    }

// --------------------------------------------------------------------------
// CHttpFile::FileHandle()
// (See comments in header file)
// --------------------------------------------------------------------------
//
RFile CHttpFile::FileHandle() const
    {
    return iFile;
    }

// --------------------------------------------------------------------------
// CHttpFile::SetHeaderL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::SetHeaderL( const TDesC8& aFieldName, 
                            const TDesC8& aFieldValue )
    {
    // if the fieldname already exists ( header already set ) -> leave
    for ( TInt i = 0; i < iHeaderArray.Count(); i++ )
        {
        if ( iHeaderArray[i]->FieldName().CompareF( aFieldName ) == 0 )
            {
            User::Leave( KErrAlreadyExists );
            }
        }

    iHeaderArray.Append( CHttpHeader::NewL( aFieldName, aFieldValue ) );
    }

// --------------------------------------------------------------------------
// CHttpFile::Headers()
// (See comments in header file)
// --------------------------------------------------------------------------
//
RPointerArray<CHttpHeader>& CHttpFile::Headers()
    {
    return iHeaderArray;
    }

// --------------------------------------------------------------------------
// CHttpFile::CreateFileInFileSystem()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::CreateFileInFileSystemL()
    {
    TInt ret = KErrNone;

    if ( iPath )
        {
        // Check first that the drive exists
        TInt driveNum;
        TParse p;
		p.Set( *iPath, NULL, NULL ); 
		TPtrC pointer = p.Drive(); 
		TLex lineParser( pointer.Ptr() ); 
		TChar ch = lineParser.Get(); 
		
		User::LeaveIfError( iFsSession.CharToDrive( ch, driveNum) );

		TVolumeInfo volumeInfo;
        User::LeaveIfError( iFsSession.Volume( volumeInfo, driveNum ) );

        // Create the file in the file system
        ret = iFile.Create( iFsSession, *iPath, EFileWrite );

        // Directory not available => create one
        if( KErrPathNotFound == ret )
            {
            // Make directory
            // Creates the directory and ignores the filename
            iFsSession.MkDirAll( *iPath );
            ret = iFile.Create( iFsSession, *iPath, EFileWrite );
            }

        // File already exists
        // File has to be renamed to 
        // <oldfilename>_<number>.<old_file_extension>
        // number will increase if same file is loaded many times
        else if( KErrAlreadyExists  == ret )
            {
            TParse parseFilename;

            parseFilename.Set( *iPath, NULL, NULL );

            HBufC* name = NULL;

            for ( TInt count = 1; count < KMaxSameFileNames; count++ )
                {
                // KSpaceForNumber is meant for underscore and number
                name = HBufC::NewLC( iPath->Length() + 
                                     KSpaceForNumber );

                TBuf<KSpaceForNumber> value;
                value.Num( count );

                name->Des().Append( parseFilename.DriveAndPath() );
                name->Des().Append( parseFilename.Name() );    
                name->Des().Append( KUnderScore() );
                name->Des().Append( value );
                name->Des().Append( parseFilename.Ext() );

                ret = iFile.Create( iFsSession, *name, EFileWrite );

                // If the file already exists make a new loop
                if ( ret == KErrAlreadyExists )
                    {
                    CleanupStack::PopAndDestroy( name );
                    name = NULL;
                    }
                // if file creation succeeded
                else if ( ret == KErrNone )
                    {
                    delete iPath;
                    iPath = name;
                    CleanupStack::Pop( name );
                    
                    count = KFinishFileCreationLoop;
                    }
                else
                    {
                    CleanupStack::PopAndDestroy( name );
                    
                    count = KFinishFileCreationLoop;
                    }
                }
            }
        }

    if( ret != KErrNone ) 
        {
        User::Leave( ret );
        }

    }

// --------------------------------------------------------------------------
// CHttpFile::DeleteFileFromFileSystemL()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::DeleteFileFromFileSystemL()
    {
    // Close filehandle before delete
    iFile.Close();

    // Delete the file
    if ( iPath )
        {
        CFileMan* fileMan = CFileMan::NewL( iFsSession );
        CleanupStack::PushL( fileMan );
        User::LeaveIfError( fileMan->Delete( iPath->Des() ) );
        CleanupStack::PopAndDestroy( fileMan );
        }
    }

// --------------------------------------------------------------------------
// CHttpFile::CloseFile()
// (See comments in header file)
// --------------------------------------------------------------------------
//
void CHttpFile::CloseFile()
    {
    iFile.Close();
    }

// end of file