// Copyright (c) 2006-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:
//

#include <mtp/mmtptype.h>
#include <mtp/mtpdatatypeconstants.h>
#include <e32base.h> 

EXPORT_C TBool MMTPType::CommitRequired() const
    {
    return EFalse;
    }
	
EXPORT_C MMTPType* MMTPType::CommitChunkL(TPtr8& /*aChunk*/)
    {
    User::Leave(KErrNotSupported);
    return NULL;
    }
    
EXPORT_C TInt MMTPType::Validate() const
    {
    return KErrNone;
    }
    
EXPORT_C void MMTPType::CopyL(const MMTPType& aFrom, MMTPType& aTo)
    {
    TBool commit(aTo.CommitRequired());
    TBool complete(EFalse);
    TPtr8 dest(NULL, 0);
    TPtrC8 src;
    TBool useAoWrite = EFalse;
    if(EMTPTypeFile == aTo.Type()) //should change later use API to get the write type
        {
        useAoWrite = ETrue;
        }
    
    TInt readErr(KErrNone);
    TInt writeErr(KErrNone);
    
    // Obtain the initial read and write chunks.
    User::LeaveIfError(readErr = aFrom.FirstReadChunk(src));
    User::LeaveIfError(writeErr = aTo.FirstWriteChunk(dest));
    
    while (!complete)
        {
        TUint dataAvailable(src.Length());
        TUint writeCapacity(dest.MaxLength() - dest.Length());
        
        complete = 
            (((readErr == KMTPChunkSequenceCompletion) && !dataAvailable) || 
            (writeErr == KMTPChunkSequenceCompletion));
            
        if (writeCapacity < dataAvailable)
            {
            if (writeCapacity)
                {
                /* 
                Write chunk capacity is available, but not enough to accomodate
                the available read chunk data. Fill the available write chunk 
                capacity and adjust the read chunk pointer.
                */
                dest.Append(src.Left(writeCapacity));                    
                src.Set(src.Right(dataAvailable - writeCapacity));
                }
                
            if (commit)
                {
                /*
                Always commit write chunks which require it, even if the write
                chunk has no capacity.
                */
                aTo.CommitChunkL(dest);   
                if(useAoWrite)
                    {
                    TInt err = KErrNone;
                    while(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
                        {
                        //let the write ao run
                        }
                    User::LeaveIfError(err);
                    }
                }

            if (writeErr != KMTPChunkSequenceCompletion)
                {
                // Obtain the next write chunk
                User::LeaveIfError(writeErr = aTo.NextWriteChunk(dest));  
                }
            }
        else if (dataAvailable)
            {
            /* 
            Write chunk can accomodate the available read chunk data. Consume
            the available read chunk data, adjust the read chunk pointer, 
            and obtain the next write chunk.
            */
            dest.Append(src);
            if (commit && (dest.Length() == dest.MaxLength() || KMTPChunkSequenceCompletion == readErr)) //doesn't commit a half chunk unless it is the last chunk
                {
                aTo.CommitChunkL(dest);
                if(useAoWrite)
                    {
                    TInt err = KErrNone;
                    while(CActiveScheduler::RunIfReady(err, CActive::EPriorityIdle))
                        {
                        //let the write ao run
                        }
                    User::LeaveIfError(err);
                    }
                }

            if (readErr != KMTPChunkSequenceCompletion)
                {
                User::LeaveIfError(readErr = aFrom.NextReadChunk(src)); 
                }
            else
                {
                src.Set(KNullDesC8);   
                }

            /*
            If the write chunk is full, and more write chunks are available, 
            obtain the next write chunk.
            */
            if ((dest.Length() == dest.MaxLength()) && (writeErr != KMTPChunkSequenceCompletion))
                {
                User::LeaveIfError(writeErr = aTo.NextWriteChunk(dest));  
                }
            }
        }        
    }

EXPORT_C TAny* MMTPType::GetExtendedInterface(TUid /*aInterfaceUid*/)
    {
    return NULL;
    }

EXPORT_C TInt MMTPType::FirstWriteChunk(TPtr8& aChunk, TUint /*aDataLength*/ )
    {
    return FirstWriteChunk(aChunk);
    }

EXPORT_C TInt MMTPType::NextWriteChunk(TPtr8& aChunk, TUint /*aDataLength*/ )
    {
    return NextWriteChunk(aChunk);
    }

EXPORT_C TBool MMTPType::ReserveTransportHeader(TUint /* aHeaderLength */, TPtr8& /* aHeader */)
    {
    return EFalse;
    }