/*

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

#include "radiostationmodel.h"

#include "radiostationmodel_p.h"

#include "radiopresetstorage.h"

#include "radioenginewrapper.h"

#include "radiouiengine.h"

#include "radiostation.h"

#include "radiostation_p.h"

#include "radiologger.h"

/*!

 *

 */

static QString parseLine( const RadioStation& station )

{

    QString line = "";

    line.append( RadioUiEngine::parseFrequency( station.frequency() ) );

    QString name = station.name();

    if ( !name.isEmpty() )

    {

        line.append( " - " );

        line.append( name.trimmed() );

    }

    LOG_FORMAT( "RadioStationModel: Returning line %s", GETSTRING(line) );

    return line;

}

/*!

 *

 */

RadioStationModel::RadioStationModel( RadioUiEngine& uiEngine ) :

    QAbstractListModel( &uiEngine ),

    d_ptr( new RadioStationModelPrivate( this, uiEngine ) )

{

}

/*!

 *

 */

RadioStationModel::~RadioStationModel()

{

}

/*!

 *

 */

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

{

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

    flags |= Qt::ItemIsEditable;

    return flags;

}

/*!

 *

 */

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

{

    Q_UNUSED( parent );

    Q_D( const RadioStationModel );

    const int count = d->mStations.keys().count();

    return count;

}

/*!

 * Checks the given station and emits signals based on what member variables had been changed

 */

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

{

    if ( !index.isValid() ) {

        return QVariant();

    }

    Q_D( const RadioStationModel );

    if ( role == Qt::DisplayRole ) {

        RadioStation station = stationAt( index.row() );

        QString firstLine = parseLine( station );

        if ( d->mDetailLevel.testFlag( RadioStationModel::ShowGenre ) ) {

            QStringList list;

            list.append( firstLine );

            QString genre = " "; // Empty space so that the listbox generates the second row

            if ( station.genre() != -1 ) {

                genre = d->mUiEngine.genreToString( station.genre() );

            }

            list.append( genre );

            return list;

        }

        return firstLine;

    } else if ( role == RadioStationModel::RadioStationRole ) {

        QVariant variant;

        variant.setValue( stationAt( index.row() ) );

        return variant;

    } else if ( role == Qt::DecorationRole &&

                d->mDetailLevel.testFlag( RadioStationModel::ShowIcons ) ) {

        RadioStation station = stationAt( index.row() );

        QVariantList list;

        if ( station.isFavorite() && !d->mFavoriteIcon.isNull() ) {

            list.append( d->mFavoriteIcon );

        } else {

            list.append( QIcon() );

        }

        if ( currentStation().frequency() == station.frequency() && !d->mNowPlayingIcon.isNull() ) {

            list.append( d->mNowPlayingIcon );

        }

        return list;

    }

    return QVariant();

}

/*!

 * Checks the given station and emits signals based on what member variables had been changed

 */

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

{

    Q_UNUSED( index );

    if ( role == RadioStationModel::ToggleFavoriteRole ) {

        const uint frequency = value.toUInt();

        RadioStation station;

        if ( findFrequency( frequency, station ) ) {

            setFavoriteByPreset( station.presetIndex(), !station.isFavorite() );

        } else {

            setFavoriteByFrequency( frequency, true );

        }

        return true;

    }

    return false;

}

/*!

 * Called by the wrapper to initialize the list with given amount of presets

 */

void RadioStationModel::initialize( RadioPresetStorage* storage, RadioEngineWrapper* engine )

{

    Q_D( RadioStationModel );

    d->mPresetStorage = storage;

    d->mEngine = engine;

    const int presetCount = d->mPresetStorage->presetCount();

    int index = d->mPresetStorage->firstPreset();

    LOG_FORMAT( "RadioStationModelPrivate::initialize: presetCount: %d, firstIndex: %d", presetCount, index );

#ifdef COMPILE_WITH_NEW_PRESET_UTILITY

    while ( index >= 0 ) {

#else

    index = 0;

    while ( index < presetCount ) {

#endif // COMPILE_WITH_NEW_PRESET_UTILITY

        RadioStation station;

        station.detach();

        RadioStationIf* preset = static_cast<RadioStationIf*>( station.data_ptr() );

        if ( d->mPresetStorage->readPreset( index, *preset ) ) {

            RADIO_ASSERT( station.isValid(), "RadioStationModelPrivate::initialize", "Invalid station" );

			// TODO: Remove this if when new Preset utility is taken into use

            if ( station.frequency() != 87500000 )

                {

                d->mStations.insert( station.frequency(), station );

                }

        }

        ++index;

#ifdef COMPILE_WITH_NEW_PRESET_UTILITY

        index = d->mPresetStorage->nextPreset( index );

#endif

    }

    d->setCurrentStation( d->mEngine->currentFrequency() );

}

/*!

 * Sets the icons to be used in the lists

 */

void RadioStationModel::setIcons( const QIcon& favoriteIcon, const QIcon& nowPlayingIcon )

{

    Q_D( RadioStationModel );

    d->mFavoriteIcon = favoriteIcon;

    d->mNowPlayingIcon = nowPlayingIcon;

}

/*!

 * Returns a reference to the station handler interface

 */

RadioStationHandlerIf& RadioStationModel::stationHandlerIf()

{

    Q_D( RadioStationModel );

    return *d;

}

/*!

 * Returns a reference to the underlying QList so that it can be easily looped

 */

const Stations& RadioStationModel::list() const

{

    Q_D( const RadioStationModel );

    return d->mStations;

}

/*!

 * Returns the station at the given index.

 */

RadioStation RadioStationModel::stationAt( int index ) const

{

    // Get the value from the keys list instead of directly accessing the values list

    // because QMap may have added a default-constructed value to the values list

    Q_D( const RadioStationModel );

    if ( index < d->mStations.keys().count() ) {

        uint frequency = d->mStations.keys().at( index );

        return d->mStations.value( frequency );

    }

    return RadioStation();

}

/*!

 * Finds a station by frequency

 */

bool RadioStationModel::findFrequency( uint frequency, RadioStation& station )

{

    Q_D( RadioStationModel );

    if ( d->mStations.contains( frequency ) ) {

        station = d->mStations.value( frequency );

        return true;

    }

    return false;

}

/*!

 * Finds a station by preset index

 */

int RadioStationModel::findPresetIndex( int presetIndex )

{

    Q_D( RadioStationModel );

    int index = 0;

    foreach( const RadioStation& tempStation, d->mStations ) {

        if ( tempStation.presetIndex() == presetIndex ) {

            return index;

        }

        ++index;

    }

    return RadioStation::NotFound;

}

/*!

 * Finds a station by preset index

 */

int RadioStationModel::findPresetIndex( int presetIndex, RadioStation& station )

{

    Q_D( RadioStationModel );

    const int index = findPresetIndex( presetIndex );

    if ( index != RadioStation::NotFound ) {

        station = d->mStations.values().at( index );

    }

    return index;

}

/*!

 * Removes a station by frequency

 */

void RadioStationModel::removeByFrequency( uint frequency )

{

    RadioStation station;

    if ( findFrequency( frequency, station ) ) {

        removeStation( station );

    }

}

/*!

 * Removes a station by preset index

 */

void RadioStationModel::removeByPresetIndex( int presetIndex )

{

    RadioStation station;

    const int index = findPresetIndex( presetIndex, station );

    if ( index >= 0 ) {

        removeStation( station );

    }

}

/*!

 * Removes the given station

 */

void RadioStationModel::removeStation( const RadioStation& station )

{

    Q_D( RadioStationModel );

    const uint frequency = station.frequency();

    if ( d->mStations.contains( frequency ) ) {

        // If we are removing the current station, copy its data to the current station pointer

        // to keep all of the received RDS data still available. They will be discarded when

        // the user tunes to another frequency, but they are available if the user decides to add it back.

        if ( d->mCurrentStation->frequency() == frequency ) {

            *d->mCurrentStation = station;

        }

        // Copy the station to a temporary variable that can be used as signal parameter

        RadioStation tempStation = station;

        const int row = modelIndexFromFrequency( tempStation.frequency() ).row();

        beginRemoveRows( QModelIndex(), row, row );

        d->mPresetStorage->deletePreset( tempStation.presetIndex() );

        d->mStations.remove( frequency );

        endRemoveRows();

        d->setCurrentStation( d->mEngine->currentFrequency() );

        if ( tempStation.isFavorite() ) {

            tempStation.setFavorite( false );

            emit favoriteChanged( tempStation );

        }

    }

}

/*!

 * Adds a new station to the list

 */

void RadioStationModel::addStation( const RadioStation& station )

{

    Q_D( RadioStationModel );

    const int newIndex = findUnusedPresetIndex();

    LOG_FORMAT( "RadioStationModelPrivate::addStation: Adding station to index %d", newIndex );

    RadioStation newStation = station;

    newStation.setPresetIndex( newIndex );

    newStation.unsetType( RadioStation::Temporary );

    // We have to call beginInsertRows() BEFORE the addition is actually done so we must figure out where

    // the new station will go in the sorted frequency order

//    int row = 0;

//    const int count = rowCount();

//    if ( count > 1 ) {

//        Stations::const_iterator iter = d->mStations.upperBound( newStation.frequency() );

//        uint iterFreq = iter.key();

//        if ( d->mStations.contains( iter.key() ) ) {

//            row = d->mStations.keys().indexOf( iter.key() );

//        } else {

//            row = count;

//        }

//    } else if ( count == 1 ) {

//        uint existingFreq = d->mStations.keys().first();

//        if ( station.frequency() > existingFreq ) {

//            row = 1;

//        }

//    }

//

    emit layoutAboutToBeChanged();

//    beginInsertRows( QModelIndex(), row, row );

    // We must add the station here because saveStation() will only update an existing station

    d->mStations.insert( newStation.frequency(), newStation );

    saveStation( newStation );

    d->setCurrentStation( d->mEngine->currentFrequency() );

//    endInsertRows();

    emit layoutChanged();

    emit stationAdded( station );

}

/*!

 * Saves the given station. It is expected to already exist in the list

 */

void RadioStationModel::saveStation( RadioStation& station )

{

    Q_D( RadioStationModel );

    const bool stationHasChanged = station.hasChanged();

    RadioStation::Change changeFlags = station.changeFlags();

    station.resetChangeFlags();

    if ( station.isType( RadioStation::Temporary ) ) {

        emitChangeSignals( station, changeFlags );

    } else if ( station.isValid() && stationHasChanged && d->mStations.contains( station.frequency() )) {

        d->mStations.insert( station.frequency(), station );

        if ( changeFlags.testFlag( RadioStation::PersistentDataChanged ) ) {

            const bool success = d->mPresetStorage->savePreset( *station.data_ptr() );

            RADIO_ASSERT( success, "RadioStationModelPrivate::saveStation", "Failed to add station" );

        }

        emitChangeSignals( station, changeFlags );

    }

}

/*!

 * Changes the favorite status of a station by its frequency. If the station does

 * not yet exist, it is added.

 */

void RadioStationModel::setFavoriteByFrequency( uint frequency, bool favorite )

{

    Q_D( RadioStationModel );

    if ( d->mEngine->isFrequencyValid( frequency ) )

    {

        LOG_FORMAT( "RadioStationModelPrivate::setFavoriteByFrequency, frequency: %d", frequency );

        RadioStation station;

        if ( findFrequency( frequency, station ) )  // Update existing preset

        {

            if ( station.isFavorite() != favorite )

            {

                station.setFavorite( favorite );

                saveStation( station );

            }

        }

        else if ( favorite )                    // Add new preset if setting as favorite

        {

            RadioStation newStation;

            if ( d->mCurrentStation->frequency() == frequency ) {

                newStation = *d->mCurrentStation;

            } else {

                LOG( "CurrentStation frequency mismatch!" );

                newStation.setFrequency( frequency );

            }

            newStation.setType( RadioStation::LocalStation | RadioStation::Favorite );

            // If PI code has been received, it is a local station

            if ( newStation.hasPiCode() ) {

                newStation.setType( RadioStation::LocalStation );

            }

            // Emit the signals only after adding the preset and reinitializing the current station

            // because the UI will probably query the current station in its slots that get called.

            addStation( newStation );

            d->setCurrentStation( frequency );

        }

    }

}

/*!

 * Changes the favorite status of a station by its preset index

 */

void RadioStationModel::setFavoriteByPreset( int presetIndex, bool favorite )

{

    LOG_FORMAT( "RadioStationModelPrivate::setFavoriteByPreset, presetIndex: %d", presetIndex );

    RadioStation station;

    if ( findPresetIndex( presetIndex, station ) != RadioStation::NotFound )

    {

        station.setFavorite( favorite );

        saveStation( station );

    }

}

/*!

 * Renames a station by its preset index

 */

void RadioStationModel::renameStation( int presetIndex, const QString& name )

{

    LOG_FORMAT( "RadioStationModelPrivate::renameStation, presetIndex: %d, name: %s", presetIndex, GETSTRING(name) );

    RadioStation station;

    if ( findPresetIndex( presetIndex, station ) != RadioStation::NotFound )

    {

        station.setUserDefinedName( name );

        saveStation( station );

    }

}

/*!

 *

 */

void RadioStationModel::setFavorites( const QModelIndexList& favorites )

{

    foreach ( const QModelIndex& index, favorites ) {

        RadioStation station = stationAt( index.row() );

        RADIO_ASSERT( station.isValid() , "RadioStationModel::setFavorites", "invalid RadioStation");

        setFavoriteByPreset( station.presetIndex(), true );

    }

}

/*!

 * Returns the currently tuned station

 */

RadioStation& RadioStationModel::currentStation()

{

    Q_D( RadioStationModel );

    return *d->mCurrentStation;

}

/*!

 * Returns the currently tuned station

 */

const RadioStation& RadioStationModel::currentStation() const

{

    Q_D( const RadioStationModel );

    return *d->mCurrentStation;

}

/*!

 * Sets the model detail level

 */

void RadioStationModel::setDetail( Detail level )

{

    Q_D( RadioStationModel );

    d->mDetailLevel = level;

}

/*!

 * Returns a list of radio stations in the given frequency range

 */

QList<RadioStation> RadioStationModel::stationsInRange( uint minFrequency, uint maxFrequency )