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


#include <implementationproxy.h>
#include <f32file.h>

#include "irdebug.h"
#include "irrecognizer.h"

// CONSTANTS
//voilate PC Lint Warning 569: Loss of information (initialization) 
//(32 bits to 31 bits)
// Uid of the recogniser
//const TUid KUidIRRecognizer={0x2000B499}

// If the file name length > 4, the file extension might be valid                  
const TInt KPlsFileExtensionsMightBeValid = 4;  
const TInt KM3uFileExtensionsMightBeValid = 4;

//extension of File to be recognised.
_LIT(KPlsExtension, ".pls");
//Mime type of the .pls file
_LIT8(KPlsMimeType,"audio/x-scpls");

_LIT(KM3uExtension, ".m3u");


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

// ---------------------------------------------------------------------------
// RecognizerEx::RecognizerEx()
// constructs the object
// ---------------------------------------------------------------------------
//
CApaRecognizerEx::CApaRecognizerEx():CApaDataRecognizerType(KIRRecognizerDllUid, 
	CApaDataRecognizerType::EHigh)
    {
    IRLOG_DEBUG( "CApaRecognizerEx::CApaRecognizerEx()" );
    // It only supports 1 mime type
    iCountDataTypes = 1;
    IRLOG_DEBUG( "CApaRecognizerEx::CApaRecognizerEx() - Exiting." );
    }

// ---------------------------------------------------------------------------
// RecognizerEx::~RecognizerEx()
// Destroys the object
// ---------------------------------------------------------------------------
//
CApaRecognizerEx::~CApaRecognizerEx()
    {
    IRLOG_DEBUG( "CApaRecognizerEx::~CApaRecognizerEx" );
    // no implementation
    }


// ---------------------------------------------------------------------------
// RecognizerEx::CreateRecognizerL()
// Returns pointer to the new object
// ---------------------------------------------------------------------------
//
CApaDataRecognizerType* CApaRecognizerEx::CreateRecognizerL()
    {
    IRLOG_DEBUG( "CApaRecognizerEx::CreateRecognizerL" );
    return new (ELeave) CApaRecognizerEx();
    }


// ---------------------------------------------------------------------------
// RecognizerEx::PreferredBufSize()
// Returns preferred buffer size
// ---------------------------------------------------------------------------
//
TUint CApaRecognizerEx::PreferredBufSize()
    {
    IRLOG_DEBUG( "CApaRecognizerEx::PreferredBufSize" );
    return 0;
    }

// ---------------------------------------------------------------------------
// RecognizerEx::SupportedDataTypeL()
// Returns supported mime type
// ---------------------------------------------------------------------------
//
TDataType CApaRecognizerEx::SupportedDataTypeL(TInt aIndex) const
    {
    IRLOG_DEBUG( "CApaRecognizerEx::SupportedDataTypeL" );
    if (0 == aIndex)
	{
        return TDataType(KPlsMimeType);
	}
	else
    {
        ASSERT(0);
        return TDataType(KNullDesC8);
    }
    }

// ---------------------------------------------------------------------------
// RecognizerEx::DoRecognizeL()
// Recognizes the file by name and/or head buffer
// ---------------------------------------------------------------------------
//
void CApaRecognizerEx::DoRecognizeL(const TDesC& aName, 
	const TDesC8& aBuffer)
    {
	IRLOG_DEBUG( "CApaRecognizerEx::DoRecognizeL" );    
    // To keep code simple, we only check file name extension
    TInt len = aBuffer.Length();
    if (aName.Length()>KPlsFileExtensionsMightBeValid)
		{
		//Compare the extension of the file to be recognised with .pls
		if (aName.Right(KPlsFileExtensionsMightBeValid).CompareF(
			KPlsExtension)==0)
	    {
			iConfidence=ECertain;   // is certainly something totally new
			iDataType=TDataType(KPlsMimeType);
			IRLOG_DEBUG( "CApaRecognizerEx::DoRecognizeL - Exiting (1)." );
			return;
		}
		else if (aName.Right(KM3uFileExtensionsMightBeValid).CompareF(
            KM3uExtension)==0)
		{
		    RecognizeM3uFileL(aName);
		    IRLOG_DEBUG( "CApaRecognizerEx::DoRecognizeL - Exiting (2)." );
		    return;
		}
	    IRLOG_DEBUG( "CApaRecognizerEx::DoRecognizeL - Exiting (3)." );					
		}
    }

void CApaRecognizerEx::RecognizeM3uFileL(const TDesC& aFileName)
{
    _LIT8(KHttpProtocol, "http");
    _LIT8(KMmsProtocol, "mms");
    _LIT8(KRtspProtocol, "rtsp");

    RFs fs;
    User::LeaveIfError(fs.Connect());
    RFile file;
    TInt ret = file.Open(fs, aFileName, EFileRead);
    if (KErrNone != ret)
    {
        fs.Close();
        return;
    }
    
    RBuf8 content;
    CleanupClosePushL(content);
    TInt maxLen = 0;
    file.Size(maxLen);
    content.CreateL(maxLen);
    file.Read(content);
    
    //try to use descriptor method to parse the buffer
    if (CheckStreamingLinksL(content, KHttpProtocol) ||
        CheckStreamingLinksL(content, KMmsProtocol) ||
        CheckStreamingLinksL(content, KRtspProtocol))
    {
        iConfidence = ECertain;
        iDataType = TDataType(KPlsMimeType);
    }
    
    CleanupStack::PopAndDestroy();
    file.Close();
    fs.Close();
}

TBool CApaRecognizerEx::CheckStreamingLinksL(TDes8& aBuffer, const TDesC8& aProtocol)
{
    TBool ret = EFalse;
    _LIT8(KNewLine, "\n");
    
    //initially, remain points to aBuffer
    TPtrC8 remain(aBuffer);
    TInt newLinePos = remain.Find(KNewLine);
    
    while (KErrNotFound != newLinePos)
    {
        //copy a new line to RBuf8
        RBuf8 left;
        CleanupClosePushL(left);
        left.CreateL(remain.Left(newLinePos));
        left.TrimLeft();
        left.LowerCase();
        
        //after trim left, does this line start with aProtocol?
        if (left.Left(aProtocol.Length()) == aProtocol)
        {
            ret = ETrue;
        }
        CleanupStack::PopAndDestroy();
        
        if (ret)
        {
            break;
        }
        else
        {
            //remain points to the right part
            remain.Set(remain.Right(remain.Length() - newLinePos - 1));
            newLinePos = remain.Find(KNewLine);
        }
    }
    
    if (!ret && remain.Length() > 0)
    {
        //last line doesn't end with '\n'
        RBuf8 last;
        CleanupClosePushL(last);
        last.CreateL(remain);
        last.TrimLeft();
        last.LowerCase();
        if (last.Left(aProtocol.Length()) == aProtocol)
        {
            ret = ETrue;
        }
        CleanupStack::PopAndDestroy();
    }
    
    return ret;
}

// -----------------------------------------------------------------------------
// ImplementationTable
// violates PC lint error :: Warning 611: Suspicious cast
// required by the ECOM framework to correctly identify the instantiation 
// method pointer to provide to a client's resolution request.
// -----------------------------------------------------------------------------
//
const TImplementationProxy ImplementationTable[] =
    {
    IMPLEMENTATION_PROXY_ENTRY(KIRRecognizerImplementationUid, 
    	CApaRecognizerEx::CreateRecognizerL)
    };
    
// ---------------------------------------------------------------------------
// ImplementationGroupProxy
// Provides access to the implementationtable
// ---------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(
	TInt& aTableCount)
    {
    IRLOG_DEBUG( "ImplementationGroupProxy" );
    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
    IRLOG_DEBUG( "ImplementationGroupProxy - Exiting." );
    return ImplementationTable;
    }