/*
* Copyright (c) 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 <e32base.h>
#include <bautils.h>
#include <syslangutil.h>
#include <PathInfo.h>
#include <data_caging_path_literals.hrh>
#include <mdsplaylisttopcharacterset.rsg>

#include "harvesterm3uplaylistparser.h"

#include "mdsutils.h"
#include "harvesterlog.h"

_LIT( KMDSM3ULineChange, "\n" );
_LIT( KMDSM3UTagExtm3u, "#EXTM3U" );
_LIT (KMDSM3UTagExtinf, "#EXTINF:" );
_LIT( KMDSM3UPoint, ",");
_LIT( KMDSM3UTagExt, "#");
_LIT( KMDSM3UAbsPath, ":\\");

const TInt KMDSM3UCarriageReturn = 13;
const TInt KMDSM3UNoOffset = 0;
const TInt KPlaylistSampleLength = 10000; 
const TUint KUnicodeBOM = 0xFEFF;
const TInt KPlaylistMaxSampleLength = 130000;
const TInt KMinimumConfidenceRequired = 75;
const TInt KMDSM3UPlaylistMaxItemCount = KMaxTInt;
const TInt KPathStartingChars = 3;

// MODULE DATA STRUCTURES
enum TMDSM3UPlaylistLineType
    {
    EMDSM3UPlaylistLineTypeExtinf = 1,
    EMDSM3UPlaylistLineTypePath = 2,
    EMDSM3UPlaylistLineTypeNotSupported = 3,
    EMDSM3UPlaylistLineTypeCorrupted = 4
    };

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::NewL
// -----------------------------------------------------------------------------
//
CHarvesterM3UPlaylistParser* CHarvesterM3UPlaylistParser::NewL( RFs& aFs,
        CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aAvailableCharacterSet,
        CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aTopCharacterSet )
    {
    CHarvesterM3UPlaylistParser* self = new ( ELeave ) CHarvesterM3UPlaylistParser(
            aFs, aAvailableCharacterSet, aTopCharacterSet );

	return self;
    }


// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CHarvesterM3UPlaylistParser::~CHarvesterM3UPlaylistParser()
    {
    Reset();
    }


// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::CHarvesterM3UPlaylistParser
// -----------------------------------------------------------------------------
//
CHarvesterM3UPlaylistParser::CHarvesterM3UPlaylistParser( RFs& aFs,
        CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aAvailableCharacterSet,
        CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* aTopCharacterSet ) 
    :iFs( aFs ), iAvailableCharacterSet( aAvailableCharacterSet ),
     iTopCharacterSet( aTopCharacterSet ), iEndLineNumber( KMDSM3UPlaylistMaxItemCount )
    {
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ParseL
// -----------------------------------------------------------------------------
//
TBool CHarvesterM3UPlaylistParser::ParseL( const TDesC& aFileName,
		RPointerArray<HBufC>& aUriArray )
    {
    iPlaylistFilePath.Set( aFileName );
    ReadPlaylistFileToBufferL();
    ParsePlaylistBufferL( aUriArray, iInvalidItems );
    
    // If at the moment, we know that there is at least one error parsing
    // with auto detect encoding, we don't need to proceed until end of
    // file anymore, this playlist file is concluded to be corrupted
    if ( iInvalidItems > 0 )
        {
        aUriArray.Reset();
        Reset();
        User::Leave( KErrCorrupt );
        }
    
    return ETrue;
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ResetL
// -----------------------------------------------------------------------------
//
void CHarvesterM3UPlaylistParser::Reset()
    {
    delete iBuffer;
    iBuffer = NULL;
    delete iLine;
    iLine = NULL;
    iBufferPtr.Set( KNullDesC );
    iCurrentLineNumber = 0;
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ReadPlaylistFileToBufferL
// -----------------------------------------------------------------------------
//
void CHarvesterM3UPlaylistParser::ReadPlaylistFileToBufferL()
    {
#ifdef _DEBUG
    WRITELOG1( "Before reading playlist to buffer: heap size = %d", User::Heap().Size() );
#endif
    
    TEntry entry;
    User::LeaveIfError( iFs.Entry( iPlaylistFilePath, entry ) );
    
    HBufC* buffer = HBufC::NewLC( entry.iSize );
    TPtr ptr = buffer->Des();

    HBufC8* buf8 = HBufC8::NewLC( entry.iSize );
    TPtr8 ptr8 = buf8->Des();

    // Read the first KPlaylistSampleLength bytes of the file
    TInt sampleLength( KPlaylistSampleLength );
    if( sampleLength > entry.iSize )
        {
        sampleLength = entry.iSize;
        }
    User::LeaveIfError( iFs.ReadFileSection(
                            iPlaylistFilePath, 0, ptr8, sampleLength ) );

    // auto detect character encoding
    TUint charSetId( 0 );
    TInt error = DetectCharacterSetL( *buf8, *iTopCharacterSet, charSetId );
    WRITELOG2("Encoding detected using top character set is 0x%x, error %d", charSetId, error);
    
    // when we fail to detect the encoding, use all available character set in the
    // system to try again. If that also fails, abandon the operation.
    if ( error )
        {
        User::LeaveIfError( DetectCharacterSetL( *buf8, *iAvailableCharacterSet, charSetId ) );
        WRITELOG1( "Encoding detected using available character set is 0x%x", charSetId );     
        }

    // read the whole file if the sample taken isn't the whole file
    if ( sampleLength != entry.iSize )
        {
        User::LeaveIfError( iFs.ReadFileSection(
                                iPlaylistFilePath, 0, ptr8, entry.iSize) );
        }
   
    // perform character conversion using the selected encoding
    TInt state( CCnvCharacterSetConverter::KStateDefault );
    TInt numOfUnconvertibleChars( 0 );
    CCnvCharacterSetConverter* charSetConv = CCnvCharacterSetConverter::NewLC();
    charSetConv->PrepareToConvertToOrFromL( charSetId, *iAvailableCharacterSet, iFs );
    TInt retVal = charSetConv->ConvertToUnicode( ptr, *buf8, state, numOfUnconvertibleChars );
    User::LeaveIfError( retVal );

    // try again if the character set wasn't detected using the whole file
    if( (retVal > 0 || numOfUnconvertibleChars > 0) && (sampleLength != entry.iSize) )
        {
        WRITELOG3( "retVal = %d, numOfUnconvertibleChars = %d, entry.iSize = %d",
                retVal, numOfUnconvertibleChars, entry.iSize );  
        numOfUnconvertibleChars = 0;
        retVal = 0;
        User::LeaveIfError( DetectCharacterSetL( *buf8, *iAvailableCharacterSet, charSetId ) );
        charSetConv->PrepareToConvertToOrFromL( charSetId, *iAvailableCharacterSet, iFs );
        retVal = charSetConv->ConvertToUnicode( ptr, *buf8, state, numOfUnconvertibleChars );
        }
        
    if ( retVal > 0 || numOfUnconvertibleChars > 0 )
        {
        WRITELOG2( "Unable to find character encoding for the playlist file. retVal = %d, numOfUnconvertibleChars = %d",
                    retVal, numOfUnconvertibleChars );     
        User::Leave( KErrNotSupported );
        }
    
    // remove the byte order mark (BOM) character prepended at the beginning
    // of the stream if encoded with unicode as per Unicode section 2.4
    if ( (charSetId == KCharacterSetIdentifierUnicodeLittle ||
         charSetId == KCharacterSetIdentifierUnicodeBig) &&
        ptr.Length() > 0 &&
        ptr[0] == KUnicodeBOM )
        {
        ptr.Delete( 0,1 );
        }
        
    iBuffer = buffer;
    iBufferPtr.Set( *iBuffer );
    
    CleanupStack::PopAndDestroy (2, buf8 ); // charSetConv & buf8    
    CleanupStack::Pop( buffer );
        
    // brand new buffer which hasn't been read, reset iCurrentLineNumber and
    // iEndLineNumber
    iCurrentLineNumber = 0;

#ifdef _DEBUG
    WRITELOG1( "After reading playlist to buffer: heap size = %d", User::Heap().Size() );
#endif
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::DetectCharacterSetL
// -----------------------------------------------------------------------------
//
TInt CHarvesterM3UPlaylistParser::DetectCharacterSetL(
            const TDesC8& aSample,
            const CArrayFix<CCnvCharacterSetConverter::SCharacterSet>& aCharacterSet,
            TUint& aCharSetId)
    {
    // CCnvCharacterSetConverter::ConvertibleToCharSetL hangs if sample is too big
    if ( aSample.Size() > KPlaylistMaxSampleLength )
        {
        User::Leave( KErrNotSupported );
        }
        
    TInt confidence( 0 );
    TInt highestConfidence( 0 );
    TUint charSetId( 0 );
    TUint highestConfidencecharSetId( 0 );

    CCnvCharacterSetConverter* charSetConv = CCnvCharacterSetConverter::NewLC();
    TInt count = aCharacterSet.Count();
    for ( TInt i=0; i < count; i++ )
        {
        charSetId = aCharacterSet.At(i).Identifier();
        charSetConv->ConvertibleToCharSetL( confidence, charSetId, aCharacterSet, aSample );
        if ( confidence > highestConfidence )
            {
            highestConfidence = confidence;
            highestConfidencecharSetId = charSetId;
            }
        }
    CleanupStack::PopAndDestroy( charSetConv );
    WRITELOG2( "CMPXM3uPlaylistImporter::DetectCharacterSetL :-> Confidence[%d] CharSetId[0x%x]",
            confidence, aCharSetId );
    if ( highestConfidence == 0 || highestConfidence < KMinimumConfidenceRequired )
        {
        return KErrNotFound;
        }
    else
        {
        aCharSetId = highestConfidencecharSetId;
        return KErrNone;
        }
    }
    
// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ParsePlaylistBufferL
// -----------------------------------------------------------------------------
//
void CHarvesterM3UPlaylistParser::ParsePlaylistBufferL(
			RPointerArray<HBufC>& aPlaylist,
            TInt& aInvalidItemCount)
    {
    // Read and process all the lines in the file
    //
    // the order of the following conditions is important. ReadNextLineL
    // should be called last to avoid skipping one line
    while ( iCurrentLineNumber < iEndLineNumber &&
               aPlaylist.Count() < KMDSM3UPlaylistMaxItemCount &&
               ReadNextLineL() )
        {
        ProcessLineL( aPlaylist, aInvalidItemCount );  
        }

    if ( aPlaylist.Count() == KMDSM3UPlaylistMaxItemCount )
        {
        Reset();
        User::Leave( KErrOverflow );
        }
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ReadNextLineL
// -----------------------------------------------------------------------------
//
TBool CHarvesterM3UPlaylistParser::ReadNextLineL()
    {
    // iBuffer should exist when this function is called
    __ASSERT_DEBUG( iBuffer, User::Leave( KErrBadDescriptor ) );

    if ( !iBufferPtr.Length() )
        {
        return EFalse;
        }

    delete iLine;
    iLine = NULL;

    // Try to find line change
    TInt offset = iBufferPtr.FindF( KMDSM3ULineChange );
  
    if( offset == KErrNotFound )
        {
        // No line change was found --> last line had no line change
        iLine = iBufferPtr.AllocL();
        // Set iBufferPtr to the end of buffer
        iBufferPtr.Set( iBufferPtr.Right(0) );
        }
    else
        {
        // Found line change
        TInt length( offset );
        if ( (offset > KMDSM3UNoOffset) && 
            (iBufferPtr[length - 1] == KMDSM3UCarriageReturn) )
            {
            --length;
            }

        iLine = iBufferPtr.Left(length).AllocL();

        // Move past the line feed
        iBufferPtr.Set( iBufferPtr.Mid(++offset) );
        }

    // Remove leading and trailing space characters from iLine's data.
    TPtr ptr = iLine->Des();
    ptr.Trim();

    iCurrentLineNumber++;
    return ETrue;
    }
    
// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ProcessLineL
// -----------------------------------------------------------------------------
//
void CHarvesterM3UPlaylistParser::ProcessLineL(
			RPointerArray<HBufC>& aPlaylist,
            TInt& aInvalidItemCount)
    {
    if ( iCurrentLineNumber == 1 ) // first line
        {
        // Check whether the file is in the extented format
        TInt offset = iLine->Find( KMDSM3UTagExtm3u );
        if( offset == KErrNotFound || offset != KMDSM3UNoOffset ||
            iLine->Length() != KMDSM3UTagExtm3u().Length() )
            {
            // The file is not in the extented format
            iExtendedFormat = EFalse;
            }
        else
            {
            // The file is in the extented format
            iExtendedFormat = ETrue;
            return;
            }        
        }
    
    // Parse line and then decide what to do with it
    switch( ParseLineL( iItem, aInvalidItemCount ) )
        {
        case EMDSM3UPlaylistLineTypeExtinf:
            // Continue to next round
            break;
            
        case EMDSM3UPlaylistLineTypePath:
            {
            // Line was a path => add item to playlist
            aPlaylist.AppendL( iItem.AllocL() );
            }
            break; 
                       
        case EMDSM3UPlaylistLineTypeNotSupported:
        case EMDSM3UPlaylistLineTypeCorrupted:
        default:
            {
            iItem = KNullDesC;
            }
            break;
        }
    }
    
// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ParseLineL
// -----------------------------------------------------------------------------
//
TInt CHarvesterM3UPlaylistParser::ParseLineL(
            TFileName& aItem,
            TInt& aInvalidItemCount)
    {
    __ASSERT_DEBUG( iLine, User::Leave(KErrAbort) );

    if( !iLine->Length() )
        {
        // Empty line => line is invalid
        return EMDSM3UPlaylistLineTypeNotSupported;
        }

    if( iExtendedFormat )
        {
        // File is in the extented format => check whether there is extented
        // info in this line.
        TInt offset = iLine->Find( KMDSM3UTagExtinf );
        if( offset != KErrNotFound && offset == KMDSM3UNoOffset )
            {
            offset = iLine->Find( KMDSM3UPoint );

            if( offset != KErrNotFound )
                {
                return EMDSM3UPlaylistLineTypeExtinf; // line type extinf
                }    
            }
        }

    // File is not in the extented format or supported info not found from this
    // line.
    switch( iLine->Find(KMDSM3UTagExt) )
        {
        case KMDSM3UNoOffset:
            // Unsupported extended info tag found from this line
            return EMDSM3UPlaylistLineTypeNotSupported;
            
        case KErrNotFound:
        default:
            // Extended info not found from the beginning of line => line is
            // a path.
            {
            // Get absolute path
            TInt error( KErrNone );
            HBufC* uri = ParseAbsolutePathLC( *iLine, error );
        
            if( error )
                {
                CleanupStack::PopAndDestroy( uri );
                ++aInvalidItemCount;
                return EMDSM3UPlaylistLineTypeCorrupted;
                }

            aItem = uri->Des();

            CleanupStack::PopAndDestroy( uri );
            
            return EMDSM3UPlaylistLineTypePath; // line type path
            }
        }
    }

// -----------------------------------------------------------------------------
// CHarvesterM3UPlaylistParser::ParseAbsolutePathLC
// -----------------------------------------------------------------------------
//
HBufC* CHarvesterM3UPlaylistParser::ParseAbsolutePathLC(
            const TDesC& aPath,
            TInt& aError)
    {
    HBufC* path = NULL;
    
    TBool isAbsolute( EFalse );
    
    if( aPath.Length() > KPathStartingChars && 
        !aPath.Mid(1, 2).CompareF( KMDSM3UAbsPath ) ) // magic: the 2nd and 3rd chars
                                               // are always ":\"
                                               // for absolute paths
        {
        isAbsolute = ETrue;
        }

    if( aPath.Length() > KMaxFileName ) // Test if path is too long
        {
        aError = KErrCorrupt;
        }
    else if( isAbsolute )
        {
        aError = KErrNone;
        aError = iFs.IsValidName( aPath ) ? KErrNone : KErrBadName;
        path = aPath.AllocLC();
        }
    else
        {
        // Given path could be relative => create absolute path and test it
        // Playlist file path
        TParse playlistPath;
        playlistPath.Set( iPlaylistFilePath, NULL, NULL );
        // Path to the folder, where playlist file is located to
        TPtrC currentFolder = playlistPath.DriveAndPath();
        // Create absolute path
        path = HBufC::NewLC( currentFolder.Length() + aPath.Length() );

        TPtr tmpPtr( path->Des() );
        tmpPtr = currentFolder;
        tmpPtr += aPath;

        aError = iFs.IsValidName(*path) ? KErrNone : KErrBadName;
        }
    
    // It is possible that a song exists in the filesystem but isn't added to
    // the database because it's not a supported type. If such song is included
    // in a playlist, it will be added to the database when the playlist is added.
    // Because of this, we cannot rely on whether the song exists in the database
    // to conclude whether the song is a broken link. We need to check for file
    // existence here. For the unsupported songs included in the playlist, they
    // will then be marked as corrupted when user initiates playback of those
    // songs.
    if ( !aError &&
         !BaflUtils::FileExists(iFs, *path) )
        {
        aError = KErrPathNotFound;
        }

    return path;
    }

// End of file