/*

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

#include <QFile>

#include <QDateTime>

#include <QVariant>

#include <QStringList>

#include <QSqlError>

#include <QSqlQueryModel>

#include <QSqlRecord>

// User includes

#include "radiohistorymodel_p.h"

#include "radiohistorymodel.h"

#include "radiohistoryitem.h"

#include "radiohistoryitem_p.h"

#include "radiostation.h"

#include "radiologger.h"

static const QLatin1String DATABASE_NAME    ( "c:\\radioplayhistory.db" );

static const QLatin1String DATABASE_DRIVER  ( "QSQLITE" );

static const QLatin1String HISTORY_TABLE    ( "history" );

static const QLatin1String SQL_CREATE_TABLE ( "CREATE TABLE history ("

                                                "id INTEGER PRIMARY KEY AUTOINCREMENT, "

                                                "artist TEXT NOT NULL, "

                                                "title TEXT NOT NULL, "

                                                "station TEXT NOT NULL, "

                                                "frequency INTEGER NOT NULL, "

                                                "tagged INTEGER NOT NULL DEFAULT 0, "

                                                "fromRds INTEGER NOT NULL DEFAULT 1, "

                                                "time INTEGER NOT NULL)" );

static const QLatin1String SQL_ADD_ITEM     ( "INSERT INTO history (artist,title,station,frequency,fromRds,time) "

                                                "VALUES ( ?,?,?,?,?,? )" );

static const QLatin1String SQL_SELECT_ALL   ( "SELECT * FROM history ORDER BY id DESC" );

static const QLatin1String SQL_SELECT_TAGGED( "SELECT * FROM history WHERE tagged=1" );// ORDER BY id DESC";

static const QLatin1String SQL_DELETE_ALL   ( "DELETE FROM history" );

static const QLatin1String SQL_DELETE_RECENT( "DELETE FROM history WHERE tagged=0" );

//static const QLatin1String SQL_DELETE_TAGGED    = "DELETE FROM history WHERE tagged=1";

static const QLatin1String SQL_CLEAR_TAGS   ( "UPDATE history SET tagged = 0 WHERE tagged = 1" );

//static static const QLatin1String SQL_FIND_ITEM_BY_ID( "SELECT * FROM history WHERE id = ?" );

static const QLatin1String SQL_TOGGLE_TAG   ( "UPDATE history SET tagged = ? WHERE id = ?" );

static const QLatin1String SQL_DELETE_ITEM_FORMAT_STR ( "DELETE FROM history WHERE id = %1" );

static const QLatin1String SQL_REMOVE_TAG_FORMAT_STR  ( "UPDATE history SET tagged = 0 WHERE id = %1" );

static const QLatin1String OR_ID_IS_FORMAT_STR        (" OR id = %1");

static const int MAX_ID_COUNT_IN_QUERY = 5;

#ifdef LOGGING_ENABLED

#   define GET_ERR( param ) GETSTRING( param.lastError().text() )

#   define GET_ERR_PTR( param ) GETSTRING( param->lastError().text() )

#endif // LOGGING_ENABLED

/*!

 * Static utility function to parse a frequency

 */

static  QString parseFrequency( const uint frequency )

{

    QString loc = qtTrId( "txt_rad_dblist_val_l1_mhz" );

    return loc.arg( RadioStation::parseFrequency( frequency ) );

}

/*!

 *

 */

RadioHistoryModelPrivate::RadioHistoryModelPrivate( RadioHistoryModel* model,

                                                    RadioUiEngine& uiEngine ) :

    q_ptr( model ),

    mUiEngine( uiEngine ),

    mRtItemClass( -1 ),

    mTopItemIsPlaying( false ),

    mShowDetails( true ),

    mViewMode( ShowAll )

{

}

/*!

 *

 */

RadioHistoryModelPrivate::~RadioHistoryModelPrivate()

{

    if ( mDatabase && mDatabase->isOpen() ) {

        mDatabase->close();

    }

}

/*!

 *

 */

bool RadioHistoryModelPrivate::connectToDatabase()

{

    LOG_METHOD;

    QSqlDatabase db = QSqlDatabase::addDatabase( DATABASE_DRIVER );

    if ( db.isValid() ) {

        mDatabase.reset( new QSqlDatabase( db ) );

        mDatabase->setDatabaseName( DATABASE_NAME );

        if ( !mDatabase->open() ) {

            LOG_FORMAT( "Failed to open database! error = %s", GET_ERR_PTR( mDatabase ) );

            mDatabase.reset();

            return false;

        }

        // Create the table if it does not exist

        if ( !mDatabase->tables().contains( HISTORY_TABLE ) ) {

            LOG( "RadioHistoryModelPrivate::connectToDatabase: Creating database tables." );

            QSqlQuery query;

            if ( !query.exec( SQL_CREATE_TABLE ) ) {

                LOG_FORMAT( "Database creation failed! error = %s", GET_ERR( query ) );

                mDatabase->close();

                mDatabase.reset();

                return false;

            }

        }

    } else {

        LOG_FORMAT( "Invalid database! error = %s", GET_ERR( db ) );

        return false;

    }

    mQueryModel.reset( new QSqlQueryModel() );

    setViewMode( ShowAll );

    return mQueryModel->lastError().type() == QSqlError::NoError;

}

/*!

 *

 */

void RadioHistoryModelPrivate::addItem( const QString& artist,

                                        const QString& title,

                                        const RadioStation& station,

                                        bool fromRds )

{

    LOG_FORMAT( "RadioHistoryModelPrivate::addItem. Artist: %s, Title: %s", GETSTRING( artist ), GETSTRING( title ) );

    if ( !mQueryModel ) {

        return;

    }

    mTopItemIsPlaying = true;

    QSqlQuery query = beginTransaction();

    query.prepare( SQL_ADD_ITEM );

    query.addBindValue( artist );

    query.addBindValue( title );

    query.addBindValue( station.name() );

    query.addBindValue( static_cast<int>( station.frequency() / 1000 ) );

    query.addBindValue( fromRds );

    query.addBindValue( QDateTime::currentDateTime().toTime_t() );

    commitTransaction( query, InsertRows, 0 );

}

/*!

 *

 */

int RadioHistoryModelPrivate::rowCount() const

{

    if ( !mQueryModel ) {

        return 0;

    }

    return mQueryModel->rowCount();

}

/*!

 *

 */

QVariant RadioHistoryModelPrivate::data( const int row, const int role ) const

{

    if ( mQueryModel->lastError().type() == QSqlError::NoError ) {

        QSqlRecord record = mQueryModel->record( row );

        if ( role == Qt::DisplayRole ) {

            QString artist = record.value( RadioHistoryValue::Artist ).toString();

            if ( artist.isEmpty() ) {

                artist = qtTrId( "txt_rad_dblist_unknown" );

            }

            const QString title = record.value( RadioHistoryValue::Title ).toString();

            const QString station = record.value( RadioHistoryValue::Station ).toString();

            const uint frequency = record.value( RadioHistoryValue::Frequency ).toUInt() * 1000;

            QStringList list;

            if ( mShowDetails ) {

                QString formatter = qtTrId( "txt_rad_dblist_1_2" );

                LOG_FORMAT( "---formatter--- %s", GETSTRING( formatter ) );

                const QString firstRow = QString( formatter ).arg( artist ).arg( title );

                LOG_FORMAT( "---firstRow--- %s", GETSTRING( firstRow ) );

                list.append( firstRow );

                const uint timeInSecs = record.value( RadioHistoryValue::Time ).toUInt();

                QDateTime dateTime;

                dateTime.setTime_t( timeInSecs );

                QString time = dateTime.toString( Qt::SystemLocaleShortDate );

                LOG_FORMAT( "---time--- %s", GETSTRING( time ) );

                QString name = !station.isEmpty() ? station : parseFrequency( frequency );

                LOG_FORMAT( "---name--- %s", GETSTRING( name ) );

                const QString secondRow = QString( formatter ).arg( time ).arg( name );

                LOG_FORMAT( "---secondRow--- %s", GETSTRING( secondRow ) );

                list.append( secondRow );

            } else {

                list.append( artist );

                list.append( title );

            }

            return list;

        } else if ( role == Qt::DecorationRole ) {

            QVariantList list;

            const bool tagged = record.value( RadioHistoryValue::Tagged ).toBool();

            if ( tagged ) {

                list.append( mTaggedIcon );

            } else {

                list.append( mNonTaggedIcon );

            }

            return list;

        }

    }

    return QVariant();

}

/*!

 *

 */

void RadioHistoryModelPrivate::removeAll( bool removeTagged )

{

    if ( !mQueryModel ) {

        return;

    }

    QSqlQuery query = beginTransaction();

    query.prepare( removeTagged ? SQL_CLEAR_TAGS : SQL_DELETE_ALL );

    // Commented out because rowsRemoved() seems to crash HbListView

//    commitTransaction( query, RemoveRows, 0, rowCount() - 1 );

    commitTransaction( query, NoOp, 0 );

    q_ptr->reset();

}

/*!

 *

 */

void RadioHistoryModelPrivate::removeByModelIndices( QModelIndexList& indices,  bool removeTags )

{

    if ( !mQueryModel ) {

           return;

    }       

    QString sqlStr = "";

    int rowIndex = -1;    

    QSqlQuery query( *mDatabase );

    mDatabase->transaction();

    // List needs to be sorted and indices needs to go throught from largest to smallest.

    // This is for keeping QmodelIndexing in sync after begin- and endremoverows

    // calls when content is not yet actually removed.

    // Real removal happens in QSqlQuery::exec

    qSort(indices);

    QModelIndexList::const_iterator iter = indices.constEnd();

    QModelIndexList::const_iterator begin = indices.constBegin();

    for ( int counter = 1; iter != begin; ) {

        iter--;

        rowIndex = (*iter).row();

        if( rowIndex > -1 ) {

            QSqlRecord record = mQueryModel->record(rowIndex);

            if( counter > 1 ) {

                sqlStr += QString( OR_ID_IS_FORMAT_STR ).arg(record.value("id").toInt());  

            } else {

                sqlStr = QString( removeTags ? SQL_REMOVE_TAG_FORMAT_STR 

                                 : SQL_DELETE_ITEM_FORMAT_STR ).arg(record.value("id").toInt());  

            }

            // adding max MAX_ID_COUNT_IN_QUERY ids to Query

            if( counter == MAX_ID_COUNT_IN_QUERY ) {

                if( !prepareAndExec( query, sqlStr ) ) {

                    // error, do not proceed

                    break;

                }

                counter = 1;

                sqlStr = "";

            } else {

                counter++;

            }   

            q_ptr->beginRemoveRows( QModelIndex(), rowIndex, rowIndex );

            q_ptr->endRemoveRows();

        }

    }

    if( !query.lastError().isValid() && sqlStr.length() ) {

        prepareAndExec( query, sqlStr );

    }

    if( query.lastError().isValid() ) {

        // in case of error, rollback everyhing and reset model

        mDatabase->rollback();

        q_ptr->reset(); 

    } else {

        mDatabase->commit();

        refreshModel();

    }

}

/*!

 *

 */

void RadioHistoryModelPrivate::setViewMode( ViewMode mode )

{

    if ( !mQueryModel ) {

        return;

    }

    mViewMode = mode;

    mQueryModel->setQuery( mode == ShowTagged ? SQL_SELECT_TAGGED : SQL_SELECT_ALL, *mDatabase );

}

/*!

 *

 */

void RadioHistoryModelPrivate::toggleTagging( const RadioHistoryItem& item, const int row )

{

    QSqlQuery updateQuery = beginTransaction();

    updateQuery.prepare( SQL_TOGGLE_TAG );

    updateQuery.addBindValue( item.isTagged() ? 0 : 1 );

    updateQuery.addBindValue( item.id() );

    Operation operation = ChangeData;

    if ( mViewMode == ShowTagged && item.isTagged() ) {

        operation = RemoveRows;

    }

    commitTransaction( updateQuery, operation, row );

}

/*!

 *

 */

RadioHistoryItem RadioHistoryModelPrivate::itemAtIndex( const QModelIndex& index ) const

{

    LOG_METHOD;

    RadioHistoryItem item;

    QSqlRecord record = mQueryModel->record( index.row() );

    item.data_ptr()->initFromRecord( record );

    return item;

}

/*!

 *

 */

void RadioHistoryModelPrivate::refreshModel()

{

    setViewMode( mViewMode );

}

/*!

 *

 */

QSqlQuery RadioHistoryModelPrivate::beginTransaction()

{

    LOG_METHOD;

    QSqlQuery newQuery( *mDatabase );

    mDatabase->transaction();

    return newQuery;

}

/*!

 *

 */

void RadioHistoryModelPrivate::commitTransaction( QSqlQuery& query, Operation operation, int start, int end )

{

    LOG_METHOD;

    if ( end == -1 ) {

        end = start;

    }

    bool success = false;

    Q_UNUSED( success );

    if ( query.exec() ) {

        if ( operation == InsertRows ) {

            q_ptr->beginInsertRows( QModelIndex(), start, end );

        } else if ( operation == RemoveRows ) {

            q_ptr->beginRemoveRows( QModelIndex(), start, end );

        }

        success = mDatabase->commit();

        LOG_ASSERT( success, LOG_FORMAT( "Commit failed! err: %s", GET_ERR_PTR( mDatabase ) ) );

        refreshModel();

        if ( operation == InsertRows ) {

            q_ptr->endInsertRows();

            q_ptr->emitItemAdded();

        } else if ( operation == RemoveRows ) {

            q_ptr->endRemoveRows();

        } else if ( operation == ChangeData ) {

            q_ptr->reportChangedData( start );

        }

    } else {

        LOG_FORMAT( "RadioHistoryModelPrivate::commitTransaction FAILED, rolling back: error = %s", GET_ERR( query ) );

        success = mDatabase->rollback();

        LOG_ASSERT( success, LOG_FORMAT( "Rollback failed! err: %s", GET_ERR_PTR( mDatabase ) ) );

    }

}

bool RadioHistoryModelPrivate::prepareAndExec( QSqlQuery& query, const QString& sqlStr )

{

    bool isOk = true;

    isOk = query.prepare(sqlStr);

    if(isOk) {

        isOk = query.exec();

    }

    return isOk;

}