/*  This file is part of the KDE project.

    Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

    This library is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 2.1 or 3 of the License.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with this library.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <QtCore/QFileInfo>

#include "quicktimemetadata.h"

#include "quicktimevideoplayer.h"

QT_BEGIN_NAMESPACE

namespace Phonon

{

namespace QT7

{

QuickTimeMetaData::QuickTimeMetaData(QuickTimeVideoPlayer *videoPlayer)

{

    m_videoPlayer = videoPlayer;

    m_movieChanged = false;

}

void QuickTimeMetaData::update()

{

    m_movieChanged = true;

    m_metaData.clear();

}

#ifdef QUICKTIME_C_API_AVAILABLE

QString QuickTimeMetaData::stripCopyRightSymbol(const QString &key)

{

    return key.right(key.length()-1);

}

QString QuickTimeMetaData::convertQuickTimeKeyToUserKey(const QString &key)

{

    if (key == QLatin1String("com.apple.quicktime.displayname"))

        return QLatin1String("nam");

    else if (key == QLatin1String("com.apple.quicktime.album"))

        return QLatin1String("alb");

    else if (key == QLatin1String("com.apple.quicktime.artist"))

        return QLatin1String("ART");

    else

        return QLatin1String("???");

}

OSStatus QuickTimeMetaData::readMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, QTPropertyClass propClass,

    QTPropertyID id, QTPropertyValuePtr *value, ByteCount *size)

{

	QTPropertyValueType type;

	ByteCount propSize;

	UInt32 propFlags;

	OSStatus err = QTMetaDataGetItemPropertyInfo(metaDataRef, item, propClass, id, &type, &propSize, &propFlags);

    BACKEND_ASSERT3(err == noErr, "Could not read meta data value size", NORMAL_ERROR, err)

    *value = malloc(propSize);

	err = QTMetaDataGetItemProperty(metaDataRef, item, propClass, id, propSize, *value, size);

    BACKEND_ASSERT3(err == noErr, "Could not read meta data value", NORMAL_ERROR, err)

    if (type == 'code' || type == 'itsk' || type == 'itlk') {

        // convert from native endian to big endian

    	OSTypePtr pType = (OSTypePtr)*value;

    	*pType = EndianU32_NtoB(*pType);

    }

	return err;

}

UInt32 QuickTimeMetaData::getMetaType(QTMetaDataRef metaDataRef, QTMetaDataItem item)

{

	QTPropertyValuePtr value = 0;

	ByteCount ignore = 0;

	OSStatus err = readMetaValue(

	    metaDataRef, item, kPropertyClass_MetaDataItem, kQTMetaDataItemPropertyID_DataType, &value, &ignore);

    BACKEND_ASSERT3(err == noErr, "Could not read meta data type", NORMAL_ERROR, 0)

    UInt32 type = *((UInt32 *) value);

    if (value)

	    free(value);

	return type;

}

QString QuickTimeMetaData::getMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, SInt32 id)

{

	QTPropertyValuePtr value = 0;

	ByteCount size = 0;

	OSStatus err = readMetaValue(metaDataRef, item, kPropertyClass_MetaDataItem, id, &value, &size);

    BACKEND_ASSERT3(err == noErr, "Could not read meta data item", NORMAL_ERROR, QString())

    BACKEND_ASSERT3(value != 0, "Could not read meta data item", NORMAL_ERROR, QString())

    QString string;

    UInt32 dataType = getMetaType(metaDataRef, item);

    switch (dataType){

    case kQTMetaDataTypeUTF8:

    case kQTMetaDataTypeMacEncodedText:

        string = PhononCFString::toQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF8, false));

        break;

    case kQTMetaDataTypeUTF16BE:

        string = PhononCFString::toQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF16BE, false));

        break;

    default:

        break;

    }

    if (value)

	    free(value);

    return string;

}

void QuickTimeMetaData::readFormattedData(QTMetaDataRef metaDataRef, OSType format, QMultiMap<QString, QString> &result)

{

	QTMetaDataItem item = kQTMetaDataItemUninitialized;

    OSStatus err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);

	while (err == noErr){

        QString key = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Key);

        if (format == kQTMetaDataStorageFormatQuickTime)

            key = convertQuickTimeKeyToUserKey(key);

        else

            key = stripCopyRightSymbol(key);

	    if (!result.contains(key)){

	        QString val = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Value);

            result.insert(key, val);

        }

        err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);

	}

}

#endif // QUICKTIME_C_API_AVAILABLE

void QuickTimeMetaData::guessMetaDataForCD()

{

    QString album = QFileInfo(m_videoPlayer->movieCompactDiscPath()).fileName();

    QString title = QFileInfo(m_videoPlayer->currentTrackPath()).fileName();

    title = title.left(title.lastIndexOf('.'));

    m_metaData.insert(QLatin1String("ALBUM"), album);

    m_metaData.insert(QLatin1String("TITLE"), title);

    m_metaData.insert(QLatin1String("TRACKNUMBER"), QString::number(m_videoPlayer->currentTrack()));

}

void QuickTimeMetaData::readMetaDataFromMovie()

{

    QMultiMap<QString, QString> metaMap;

#ifdef QUICKTIME_C_API_AVAILABLE

    QTMetaDataRef metaDataRef;

	OSStatus err = QTCopyMovieMetaData([m_videoPlayer->qtMovie() quickTimeMovie], &metaDataRef);

    BACKEND_ASSERT2(err == noErr, "Could not read QuickTime meta data", NORMAL_ERROR)

    readFormattedData(metaDataRef, kQTMetaDataStorageFormatUserData, metaMap);

    readFormattedData(metaDataRef, kQTMetaDataStorageFormatQuickTime, metaMap);

    readFormattedData(metaDataRef, kQTMetaDataStorageFormatiTunes, metaMap);

#else

	NSString *name = [m_videoPlayer->qtMovie() attributeForKey:@"QTMovieDisplayNameAttribute"];

	metaMap.insert(QLatin1String("nam"), QString::fromUtf8([name UTF8String]));

#endif // QUICKTIME_C_API_AVAILABLE

    m_metaData.insert(QLatin1String("ARTIST"), metaMap.value(QLatin1String("ART")));

    m_metaData.insert(QLatin1String("ALBUM"), metaMap.value(QLatin1String("alb")));

    m_metaData.insert(QLatin1String("TITLE"), metaMap.value(QLatin1String("nam")));

    m_metaData.insert(QLatin1String("DATE"), metaMap.value(QLatin1String("day")));

    m_metaData.insert(QLatin1String("GENRE"), metaMap.value(QLatin1String("gnre")));

    m_metaData.insert(QLatin1String("TRACKNUMBER"), metaMap.value(QLatin1String("trk")));

    m_metaData.insert(QLatin1String("DESCRIPTION"), metaMap.value(QLatin1String("des")));

}

void QuickTimeMetaData::readMetaData()

{

	if (!m_videoPlayer)

        return;

    if (m_videoPlayer->mediaSource().type() == Phonon::MediaSource::Disc)

        guessMetaDataForCD();

    else

        readMetaDataFromMovie();

}

QMultiMap<QString, QString> QuickTimeMetaData::metaData()

{

    if (m_videoPlayer && m_videoPlayer->hasMovie() && m_movieChanged)

        readMetaData();

    return m_metaData;

}

}}

QT_END_NAMESPACE