/*
* Copyright (c) 2002-2004 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:  Implements double buffering storage functionality for OMA downloads
*
*/


#include <bldvariant.hrh>

#include "FileExt.h"
#include "FileSaver.h"
#include "CodBuffStorage.h"
#include "CodLogger.h"
#include "HeaderField.h"
#include <SysUtil.h>
#include <DocumentHandler.h>
#include <APMSTD.H>
#include <f32file.h>


#ifdef RD_MULTIPLE_DRIVE
#include <driveinfo.h>
#endif //RD_MULTIPLE_DRIVE

// EXTERNAL DATA STRUCTURES
//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  
//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS
//const ?type ?constant_var = ?constant;

// ---------------------------------------------------------
// CCodBuffStorage::CCodBuffStorage
// ---------------------------------------------------------
//
CCodBuffStorage::CCodBuffStorage( CFileSaver* aSaver )
:CActive( EPriorityHigh ), 
 iFile(&(aSaver->iFile)),
 iDownloadedSize(aSaver->iSize), 
 iBufferedSize(aSaver->iBufferedSize),
 iHttpStorageBufferSize(aSaver->iBufferSize),
 iHttpStorageLength(aSaver->iLength),
 iProgressiveDownload(aSaver->iProgressiveDownload)
    {
    }

// -----------------------------------------------------------------------------
// CCodBuffStorage::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCodBuffStorage::ConstructL()
    {
   
    CLOG(( ECodStorage, 0, _L("-> CCodBuffStorage::ConstructL") ));
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CCodBuffStorage::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCodBuffStorage* CCodBuffStorage::NewL( CFileSaver* aHttpStorage )
    {
    CCodBuffStorage* self = new( ELeave ) CCodBuffStorage( aHttpStorage );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

// ---------------------------------------------------------
// CCodBuffStorage::~CCodBuffStorage
// ---------------------------------------------------------
//
CCodBuffStorage::~CCodBuffStorage()
    {
    Cancel();

    ResetBuffers();

    delete iWritePtr; iWritePtr = 0;
    }



// ---------------------------------------------------------
// CCodBuffStorage::RunL
// ---------------------------------------------------------
//
void CCodBuffStorage::RunL()
    {
    
    CLOG(( ECodStorage, 0, _L("-> CCodBuffStorage::RunL") ));
    // Save the error code
    iLastWriteErrorCode = iStatus.Int();

    if(iLastWriteErrorCode==KErrNone && iWritePtr)
        {
        // Update how much was written on the file
        iDownloadedSize += iWritePtr->Length();
        
        CLOG(( ECodStorage, 2, _L("(%08X) CCodBuffStorage::RunL: Async write finished, downloaded now: %d"), \
                 this, iDownloadedSize ));
        }
    else
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::RunL DH-iStat: %d,"), \
               this, iStatus.Int()  ));
        }
  
    if(iWait.IsStarted())
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::RunL Stopping iWait"), \
               this ));
        iWait.AsyncStop();
        }
    }

void CCodBuffStorage::DoCancel()
    {
    CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoCancel"), \
        this ));

    // This is ok, CActive::Cancel always waits for the async operation to finish in this case
    iLastWriteErrorCode = KErrCancel;
    }

// ---------------------------------------------------------
// CCodBuffStorage::ResetBuffer
// ---------------------------------------------------------
//
void CCodBuffStorage::ResetBuffers()
    {
    CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::ResetBuffers >>"), \
        this ));


    if(IsActive())
        {
        // Make sure async writes are finished
        iWait.Start();
        }

    // Cleanup
    delete iBuff1; iBuff1 = NULL;
    delete iBuff2; iBuff2 = NULL;
    iClientBuffer = NULL;
    iBufferSize = 0;
    
    CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::ResetBuffers <<"), \
           this ));

    }
    
    
// ---------------------------------------------------------
// CCodBuffStorage::WriteOutNextBodyDataL
// ---------------------------------------------------------
//
TBool CCodBuffStorage::WriteOutNextBodyDataL( const TDesC8& aBuf )
    {
    TBool retVal( ETrue );
    
    if( iFile )
        {
        
        if(iDownloadedSize <= 0)
            {
            TInt len = aBuf.Length();
            User::LeaveIfError( iFile->Write( aBuf ) );
            User::LeaveIfError( iFile->Flush() );
    	    // Update how much written to file
   		    iDownloadedSize += len;
            }
        else
            {
            DoBufferingWriteL(aBuf);    
            }
        }        
  

    if( iHttpStorageLength != KDefaultContentLength &&
        iBufferedSize > iHttpStorageLength )
        // we don't know actually how many bytes will come down.
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::WriteOutNextBodyDataL: Length modified"), \
               this ));

        iHttpStorageLength = KDefaultContentLength;
        retVal = EFalse;
        }
        
    return retVal;
    }

// ---------------------------------------------------------
// CCodBuffStorage::FlushBuffersL
// ---------------------------------------------------------
//
void CCodBuffStorage::FlushBuffersL()
    {
    if(!iFile)
        {
        return;
        }

    CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL >>"), \
           this ));


    // Make sure async writes are finished before doing anything
    if(IsActive())
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL  stalling >>"), \
                this ));

        iWait.Start();
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL  stalling <<"), \
               this ));

        }

     if(iLastWriteErrorCode != KErrNone)
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL: last error = %d"), \
               this, iLastWriteErrorCode ));

        TInt err = iLastWriteErrorCode;
        iLastWriteErrorCode = KErrNone;
        User::Leave(err);
        }

    if(iClientBuffer)
        {
        // Flush whatever is left on the client buffer
        TInt len = iClientBuffer->Length();

        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL: %d bytes"), \
            this, len ));


        if(len > 0)
            {
            // Write to file
            TPtr8 des(iClientBuffer->Des());

            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL before iFile->Write(des)"),this ));
            User::LeaveIfError(iFile->Write(des));
            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL after iFile->Write(des)"), this ));

             // Update how much was written to file
            iDownloadedSize += len;

            des.Zero();
            }
        }

    CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::FlushBuffersL  <<"), \
        this ));

   }

// ---------------------------------------------------------
// CCodBuffStorage::DoBufferingWriteL
// ---------------------------------------------------------
//        
void CCodBuffStorage::DoBufferingWriteL(const TDesC8& aBuf)
    {
    if((iBufferSize != iHttpStorageBufferSize )|| (iClientBuffer == NULL))
        {
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: Allocate %d - downloaded %d"), \
        this, iHttpStorageBufferSize, iBufferedSize ));

        
        // Make sure nothing is leaked
        delete iBuff1; iBuff1 = 0;
        delete iBuff2; iBuff2 = 0;
        iBufferSize = 0;
        
        // Allocate buffers
        iBuff1 = HBufC8::NewL(iHttpStorageBufferSize);
        iBuff2 = HBufC8::NewL(iHttpStorageBufferSize);

        // Mark that we now have buffers that are iBufferSize big
        iBufferSize = iHttpStorageBufferSize;

        // Set client to use buffer 1
        iClientBuffer = iBuff1;
        
        }

    // Get incoming data pointer and size
    const TUint8* src = aBuf.Ptr();
    TInt incomingBuffSize = aBuf.Length();
    
    // Process the data in blocks  
    while(incomingBuffSize)
        {
        // Get pointer to current client buffer data (at start of loop since iClientBuffer can change)
        TPtr8 buff = iClientBuffer->Des();
        TInt buffLength = buff.Length();

        // How much space in the buffer
        TInt toFillUp = iBufferSize - buffLength;

        // Check if we can just fit everything in the current buffer
        if(incomingBuffSize < toFillUp)
            {  
            // Dump data on the current client buffer since ample space exists
            buff.Append(src, incomingBuffSize);

            // Update the 'received' counter on how much we got from air
            iBufferedSize += incomingBuffSize;

            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: Copied %d, now %d / %d"), \
                   this, incomingBuffSize, buff.Length(), iBufferSize ));


            // And break out of the loop since we're finished for this round
            break;
            }
            
        // At this point we have data that either fills or overflows the buffer so append as much as fits
        buff.Append( src, toFillUp );

        // Update the 'received' counter on how much we copied
        iBufferedSize+=toFillUp;

        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: Copied %d, now %d / %d"), \
               this, toFillUp, buff.Length(), iBufferSize ));


        // Subtract how much we copied from the loop counter and advance source data pointer
        incomingBuffSize -= toFillUp;
        src+=toFillUp;

        // Now we have a full client buffer, better do something with it
    
        // Check if previous async write is still ongoing
        // Done here so if somebody switched on progressive download midway through we don't mix buffers
        if(IsActive())
            {
            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: stalling >>"), \
                   this ));

            iWait.Start();
            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: stalling <<"), \
                   this ));

             }

        // In case of async writes we have to check if there was error previously
        if(iLastWriteErrorCode != KErrNone)
            {
            // Clear the error code and leave with it
            TInt err = iLastWriteErrorCode;
            iLastWriteErrorCode = KErrNone;
            User::Leave(err);
            }

        if(iProgressiveDownload)
            {
            CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL: Buffer full -> Progressive download"), \
                   this ));

            TInt len = buff.Length();

            // Progressive download -> just do a synchronous write and update counter
            User::LeaveIfError(iFile->Write(buff));
            
            // Update received counter
            //iBufferedSize += toFillUp;

            // Update how much was written to file (sync write)
            iDownloadedSize += len;

            // Clear out client buffer
            buff.Zero();
            
            // Continue for next write
            continue;
            }

        // We must keep the descriptor alive until async operations have finished
        if(!iWritePtr)
            {
            iWritePtr = new (ELeave) TPtr8(iClientBuffer->Des());
            }
        else
            {
            iWritePtr->Set(iClientBuffer->Des());
            }

#ifdef _DEBUG
        // Print out file position so we can check alignments
        TInt currentPos(0);
        iFile->Seek(ESeekCurrent, currentPos);
        
        CLOG(( ECodStorage, 2, _L("(%08X)  CCodBuffStorage::DoBufferingWriteL - Start async write %d bytes, filepos=%d"), \
               this, iWritePtr->Length(), currentPos ));

#endif

        // Start the async write and set AO active
        iFile->Write( *iWritePtr, iStatus ) ;
        SetActive();

        // Swap buffer pointers (we can't use the same buffer here 
        // since it is not known when the buffer can be used again)
        if(iClientBuffer == iBuff1)
            {
            iClientBuffer = iBuff2;
            }
        else
            {
            iClientBuffer = iBuff1;
            }

        // Make sure the new client buffer is empty
        iClientBuffer->Des().Zero();
        }
    }