/*

* 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:

*

*/

// System includes

#include <QStringList>

// User includes

#include "radiohistorymodel.h"

#include "radiohistorymodel_p.h"

#include "radiouiengine.h"

#include "radiohistoryitem.h"

#include "radiostation.h"

#include "radiouiengine.h"

#include "radio_global.h"

#include "radiologger.h"

/*!

 *

 */

RadioHistoryModel::RadioHistoryModel( RadioUiEngine& uiEngine ) :

    QAbstractListModel( &uiEngine ),

    d_ptr( new RadioHistoryModelPrivate( this, uiEngine ) )

{

    connectAndTest( &uiEngine,  SIGNAL(tunedToFrequency(uint,int)),

                    this,       SLOT(resetCurrentSong()) );

    connectAndTest( &uiEngine,  SIGNAL(seekingStarted(int)),

                    this,       SLOT(resetCurrentSong()) );

}

/*!

 *

 */

RadioHistoryModel::~RadioHistoryModel()

{

    Q_D( RadioHistoryModel );

    d->mItems.clear();

    delete d_ptr;

}

/*!

 * \reimp

 */

Qt::ItemFlags RadioHistoryModel::flags ( const QModelIndex& index ) const

{

    Qt::ItemFlags flags = QAbstractListModel::flags( index );

    flags |= Qt::ItemIsEditable;

    return flags;

}

/*!

 * \reimp

 */

int RadioHistoryModel::rowCount( const QModelIndex& parent ) const

{

    Q_UNUSED( parent );

    Q_D( const RadioHistoryModel );

    return d->mItems.count();

}

/*!

 * \reimp

 */

QVariant RadioHistoryModel::data( const QModelIndex& index, int role ) const

{

    if ( !index.isValid() ) {

        return QVariant();

    }

    Q_D( const RadioHistoryModel );

    if ( role == Qt::DisplayRole ) {

        RadioHistoryItem item = d->mItems.at( index.row() );

        QStringList list;

        if ( d->mShowDetails ) {

            list.append( item.artist() + " - " + item.title() );

            list.append( item.time() + " " + item.station() + " " /*+ RadioUiEngine::parseFrequency( item.frequency() ) */ );

        } else {

            list.append( item.artist() );

            list.append( item.title() );

        }

        return list;

    }

    return QVariant();

}

/*!

 * \reimp

 */

bool RadioHistoryModel::setData( const QModelIndex& index, const QVariant& value, int role )

{

    Q_UNUSED( value );

    if ( !index.isValid() ) {

        return false;

    }

    if ( role == RadioHistoryModel::SetFavoriteRole ) {

        Q_D( RadioHistoryModel );

        RadioHistoryItem item = d->mItems.at( index.row() );

        item.setFavorite();

        updateItem( index.row(), item );

        return true;

    }

    return false;

}

/*!

 * Public slot

 */

void RadioHistoryModel::resetCurrentSong()

{

    Q_D( RadioHistoryModel );

    d->mTopItemIsPlaying = false;

    emit currentSongReset();

}

/*!

 * Public slot

 */

void RadioHistoryModel::setFavorite()

{

    Q_D( RadioHistoryModel );

    RadioHistoryItem item = d->mItems.first();

    item.setFavorite();

    updateItem( 0, item );

}

/*!

 * Public slot

 */

void RadioHistoryModel::removeAll()

{

    Q_D( RadioHistoryModel );

    beginRemoveRows( QModelIndex(), 0, rowCount() - 1 );

    d->mItems.clear();

    endRemoveRows();

}

/*!

 *

 */

bool RadioHistoryModel::isCurrentSongRecognized() const

{

    Q_D( const RadioHistoryModel );

    return d->mTopItemIsPlaying;

}

/*!

 *

 */

void RadioHistoryModel::setShowDetails( bool showDetails )

{

    Q_D( RadioHistoryModel );

    d->mShowDetails = showDetails;

    reset();

}

/*!

 *

 */

void RadioHistoryModel::addItem( const QString& artist, const QString& title, const RadioStation& station )

{

    Q_D( RadioHistoryModel );

    RadioHistoryItem item;

    const int itemIndex = findItem( artist, title, item );

    if ( itemIndex != -1 ) {

        item.increasePlayCount();

        updateItem( itemIndex, item, true );

    } else {

        item.setArtist( artist );

        item.setTitle( title );

        item.setStation( station.name() );

        item.setFrequency( station.frequency() );

        item.setCurrentTime();

        beginInsertRows( QModelIndex(), 0, 0 );

        d->mItems.prepend( item );

        endInsertRows();

    }

    d->mTopItemIsPlaying = true;

    emit itemAdded();

}

/*!

 *

 */

void RadioHistoryModel::clearRadioTextPlus()

{

    Q_D( RadioHistoryModel );

    d->mRtItemHolder = "";

    resetCurrentSong();

}

/*!

 *

 */

void RadioHistoryModel::addRadioTextPlus( int rtClass, const QString& rtItem, const RadioStation& station )

{

    if ( rtClass == RtPlus::Artist || rtClass == RtPlus::Title ) {

        Q_D( RadioHistoryModel );

        if ( d->mRtItemHolder.isEmpty() ) {

            d->mRtItemHolder = rtItem;

        } else {

            if ( rtClass == RtPlus::Title ) {

                addItem( d->mRtItemHolder, rtItem, station );

            } else {

                addItem( rtItem, d->mRtItemHolder, station );

            }

            d->mRtItemHolder = "";

        }

    }

}

/*!

 *

 */

int RadioHistoryModel::findItem( const QString& artist, const QString& title, RadioHistoryItem& item )

{

    Q_D( RadioHistoryModel );

    const int itemCount = d->mItems.count();

    for ( int i = 0; i < itemCount; ++i ) {

        RadioHistoryItem existingItem = d->mItems.at( i );

        if ( existingItem.artist().compare( artist ) == 0

             && existingItem.title().compare( title ) == 0 ) {

            item = existingItem;

            return i;

        }

    }

    return -1;

}

/*!

 *

 */

void RadioHistoryModel::updateItem( int index, const RadioHistoryItem& item, bool prepend )

{

    Q_D( RadioHistoryModel );

    d->mItems.removeAt( index );

    if ( prepend ) {

        d->mItems.prepend( item );

    } else {

        d->mItems.insert( index, item );

    }

}