/*

* 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: Framework wraper - Private.

*

*/

#include <QRegExp>

#include <QStringList>

#include <QFileInfo>

#include <QDateTime>

#include <QTime>

#include <QDate>

#include <mpxplaybackutility.h>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediadrmdefs.h>

#include "mpmpxdetailsframeworkwrapper_p.h"

#include "mpmpxdetailsframeworkwrapper.h"

#include "mpcommondefs.h"

#include "mptrace.h"

#include "mpsongdata.h"

/*!

    \class MpMpxDetailsFrameworkWrapperPrivate

    \brief Wrapper for mpx framework utilities - private implementation.

    This is a private implementation of the mpx framework wrapper utilties interface.

*/

/*!

 \internal

 */

MpMpxDetailsFrameworkWrapperPrivate::MpMpxDetailsFrameworkWrapperPrivate( MpMpxDetailsFrameworkWrapper *qq )

    : q_ptr( qq ),

      iSongData(0),

      iPlaybackUtility(0)

{

    TX_LOG

}

/*!

 \internal

 */

MpMpxDetailsFrameworkWrapperPrivate::~MpMpxDetailsFrameworkWrapperPrivate()

{

    TX_ENTRY

    if ( iPlaybackUtility )

        {        

        TRAP_IGNORE(iPlaybackUtility->RemoveObserverL( *this ));

        iPlaybackUtility->Close();

        iPlaybackUtility = NULL;

        //do not delete pointer data

        }

    delete iSongData;

    iSongData=NULL;

    TX_EXIT

}

/*!

 \initialize wrapper

 */

void MpMpxDetailsFrameworkWrapperPrivate::init( TUid hostUid )

{

    mHostUid = hostUid;

    TRAPD(err, DoInitL());

    if ( err != KErrNone ) {

        TX_LOG_ARGS("Error: " << err << "; should never get here.");

    }

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::DoInitL()

{

    TX_ENTRY

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( mHostUid );

    iPlaybackUtility->AddObserverL( *this );

    iSongData = new MpSongData();

    User::LeaveIfNull(iSongData);

    TX_EXIT

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::HandlePlaybackMessage(

        CMPXMessage *aMessage,

        TInt aError )

{

    Q_UNUSED( aMessage );

    Q_UNUSED( aError );

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::HandlePropertyL( TMPXPlaybackProperty /*aProperty*/, TInt /*aValue*/, TInt /*aError*/ )

{

    TX_LOG

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::HandleSubPlayerNamesL( TUid /*aPlayer*/, const MDesCArray */*aSubPlayers*/, TBool /*aComplete*/, TInt /*aError*/ )

{

    TX_LOG    

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::HandleMediaL(

        const CMPXMedia& aProperties,

        TInt aError )

{

    TX_ENTRY

    if ( KErrNone != aError ){

        // TODO: Hkn: Add a proper trace macro and trace

        TX_EXIT

        return;

    }

    bool changed = false;

    if ( aProperties.IsSupported( KMPXMediaGeneralTitle ) ) {

        changed |= iSongData->setTitle(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaGeneralTitle ).Ptr(),

                aProperties.ValueText( KMPXMediaGeneralTitle ).Length() ) );

    } else {

        changed |= iSongData->setTitle( QString() );

    }

    if ( aProperties.IsSupported( KMPXMediaMusicArtist ) ) {

        changed |= iSongData->setArtist(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicArtist ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicArtist ).Length() ) );

    } else {

        changed |= iSongData->setArtist( QString() );

    }

    if ( aProperties.IsSupported( KMPXMediaMusicAlbum ) ) {

        changed |= iSongData->setAlbum(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicAlbum ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicAlbum ).Length() ) );

    } else {

        changed |= iSongData->setAlbum( QString() );

    }

    if ( changed ) {

        iSongData->commitPlaybackInfo( );

    }    

    // call back will be called when Album art is retrieved

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) ) ) {        

        iSongData->setAlbumArtUri( 

                QString::fromUtf16(

                        aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Ptr(),

                        aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Length() ) );

    } else {

        iSongData->setAlbumArtUri( QString() );

    }

    // all following will be for song details

    changed = false;  

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaGeneralUri ) ) ) {

        QString fullName = QString::fromUtf16(

                aProperties.ValueText( KMPXMediaGeneralUri ).Ptr(),

                aProperties.ValueText( KMPXMediaGeneralUri ).Length() );

        TX_LOG_ARGS( "File name with path: " << fullName );

        // get size & last modifed information from file system

        QFileInfo info( fullName );

        changed |= iSongData->setSize( info.size() );

        QDateTime lastModified = info.lastModified();

        QDate date = lastModified.date();

        int day = date.day();

        int month = date.month();

        int year = date.year();

        QTime time = lastModified.time();

        int sec = time.second();

        int min = time.minute();

        int hr = time.hour();

        QString lastModifiedStr("%1.%2.%3 %4:%5:%6");

        lastModifiedStr = lastModifiedStr.arg( day ).arg( month ).arg( year ).arg( hr ).arg( min ).arg( sec );

        changed |= iSongData->setModified( lastModifiedStr );

        // get file name without suffix

        QString file;

        QRegExp rx("(.+)\\..+");

        QString str = info.fileName();

        TX_LOG_ARGS( "File name with suffix = " << str );

        int pos = rx.indexIn( str );

        if( pos > -1 ) {

            file = rx.cap( 1 );

            TX_LOG_ARGS( "File = " << file );

        }

        changed |= iSongData->setFileName( file );

    } else {

        changed |= iSongData->setFileName( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicComposer ) ) ) {

        TX_LOG_ARGS( "Composer is supported " );

        changed |= iSongData->setComposer(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicComposer ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicComposer ).Length() ) );

    } else {

        changed |= iSongData->setComposer( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicYear ) ) ) {

        TInt64 yearInMicroSeconds = aProperties.ValueTObjectL<TInt64>( KMPXMediaMusicYear );

        TX_LOG_ARGS( "year = " << yearInMicroSeconds );

        TTime yearTime( yearInMicroSeconds );

        changed |= iSongData->setYear( yearTime.DateTime().Year() );

    } else {

        // to clear previous result

        changed |= iSongData->setYear( -1 );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicAlbumTrack ) ) ) {

        changed |= iSongData->setAlbumTrack(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicAlbumTrack ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicAlbumTrack ).Length() ) );

    } else {

        changed |= iSongData->setAlbumTrack( QString() );  

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicGenre ) ) ) {

        changed |= iSongData->setGenre(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicGenre ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicGenre ).Length() ) );

    } else {

        changed |= iSongData->setGenre( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaGeneralMimeType ) ) ) {

        QString type = QString::fromUtf16(

                            aProperties.ValueText( KMPXMediaGeneralMimeType ).Ptr(),

                            aProperties.ValueText( KMPXMediaGeneralMimeType ).Length() );

        QString regularExpression(".+/(.+)");                            

        QRegExp rx(regularExpression);

        QString mimeType;

        int pos = rx.indexIn( type );

        if( pos > -1 ) {

            mimeType = rx.cap( 1 );

            mimeType = mimeType.toUpper();

            TX_LOG_ARGS( "MIME type =" << mimeType );

        }        

        changed |= iSongData->setMimeType( mimeType );  

    } else {

        changed |= iSongData->setMimeType( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaGeneralDuration ) ) ) {

        TInt duration( aProperties.ValueTObjectL<TInt>( KMPXMediaGeneralDuration ) );

        changed |= iSongData->setDuration( duration / 1000 );

    } else {

        changed |= iSongData->setDuration( -1 );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaAudioBitrate  ) ) ) {

        TInt bitRate( aProperties.ValueTObjectL<TInt>( KMPXMediaAudioBitrate ) );

        changed |= iSongData->setBitRate( bitRate );

    } else {

        changed |= iSongData->setBitRate( -1 );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaAudioSamplerate  ) ) ) {

        TInt sampleRate( aProperties.ValueTObjectL<TInt>( KMPXMediaAudioSamplerate ) );

        changed |= iSongData->setSampleRate( sampleRate );

    } else {

        changed |= iSongData->setSampleRate( -1 );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaGeneralCopyright ) ) ) {

        changed |= iSongData->setCopyright(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaGeneralCopyright ).Ptr(),

                aProperties.ValueText( KMPXMediaGeneralCopyright ).Length() ) );

    } else {

        changed |= iSongData->setCopyright( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaMusicURL ) ) ) {

        changed |= iSongData->setMusicURL(

            QString::fromUtf16(

                aProperties.ValueText( KMPXMediaMusicURL ).Ptr(),

                aProperties.ValueText( KMPXMediaMusicURL ).Length() ) );

    } else {

        changed |= iSongData->setMusicURL( QString() );

    }

    if ( aProperties.IsSupported( TMPXAttribute( KMPXMediaDrmProtected ) ) ) {

    TX_LOG_ARGS( "DRM is supported." );

        changed |= iSongData->setDrmProtected( aProperties.ValueTObjectL<TBool>( KMPXMediaDrmProtected ) );

    } else {

        changed |= iSongData->setDrmProtected( false );

    } 

    if ( changed ) {

        iSongData->commitSongDetailInfo( );

    }    

    TX_EXIT

}

/*!

 return song data

 */

MpSongData *MpMpxDetailsFrameworkWrapperPrivate::songData()

{

    TX_LOG

    return iSongData;

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::retrieveSong()

{

    TX_ENTRY

    TRAP_IGNORE( doRetrieveSongL() );

    TX_EXIT

}

/*!

 \internal

 */

void MpMpxDetailsFrameworkWrapperPrivate::doRetrieveSongL()

{

    TX_ENTRY

    MMPXSource *mediaSrc = iPlaybackUtility->Source();

    User::LeaveIfNull( mediaSrc );

    RArray<TMPXAttribute> requestedAttr;

    CleanupClosePushL( requestedAttr );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralTitle ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicArtist ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbum ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralUri ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumTrack ) );   

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicComposer ) );   

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicYear ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicGenre ) );   

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralMimeType ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralDuration ) );    

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaAudioBitrate ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaAudioSamplerate ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralCopyright ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicURL ) );

    requestedAttr.AppendL( TMPXAttribute( KMPXMediaDrmProtected ) );    

    mediaSrc->MediaL( requestedAttr.Array(), *this );

    CleanupStack::PopAndDestroy( &requestedAttr );

    TX_EXIT

}