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

#include "irfavoritesdb.h"
#include "irqfavoritesdb.h"
#include "irqfavoritesdb_p.h"
#include "irqenums.h"
#include "irqutility.h" 
#include "irqisdsdatastructure.h"
#include "irpreset.h"
#include "irisdspreset.h"

IRQFavoritesDBPrivate::IRQFavoritesDBPrivate(IRQFavoritesDB *aIRQFavorites) : q_ptr(aIRQFavorites),
                                                                              mIRFavoritesDb(NULL)
{
}

IRQFavoritesDBPrivate::~IRQFavoritesDBPrivate()
{
    delete mIRFavoritesDb;
    mIRFavoritesDb = NULL;
}

void IRQFavoritesDBPrivate::init()
{
    TRAPD(err, mIRFavoritesDb = CIRFavoritesDb::NewL());
    if (KErrNone != err)
    {
        return;
    }

    /* add self to the observers of the CIRFavoritesDb. When the call back function
    * is called, it means that preset is changed and we send a signal to the uper layer*/
    mIRFavoritesDb->AddObserver(*this);
}

int IRQFavoritesDBPrivate::addPreset(const IRQPreset& aPreset)
{
    int returnCode = 0;
    TRAPD(err, addPresetL(aPreset, returnCode));
    
    int result = 0;
    if (KErrNone != err)
    {
        IRQUtility::convertSError2QError(err, result);
    }
    else
    {
        IRQUtility::convertSError2QError(returnCode, result);
    }
    return result;
}

int IRQFavoritesDBPrivate::addPreset(const QString& aName, const QString& aURL)
{
    if (0 == aName.size() || 0 == aURL.size())
    {
        return EIRQErrorBadParameter;
    }
    
    TPtrC16 nameptr(reinterpret_cast<const TUint16*> (aName.utf16()));
    TPtrC16 urlptr(reinterpret_cast<const TUint16*> (aURL.utf16()));
    int returnCode = 0;
    TRAPD(err, mIRFavoritesDb->AddPresetL(nameptr, urlptr, returnCode));
    
    int result = 0;
    if (KErrNone != err)
    {
        IRQUtility::convertSError2QError(err, result);
    }
    else
    {
        IRQUtility::convertSError2QError(returnCode, result);
    }
    return result;
}

int IRQFavoritesDBPrivate::getUniqId(int aNum) const
{
    if ( aNum < 0 || aNum >= mIRFavoritesDb->iFavPresetList.Count())
    {
        return EIRQErrorBadParameter;
    }
        
    //the preset's uniqid is equal to the CIRPreset's id
    return mIRFavoritesDb->iFavPresetList[aNum]->Id();
}

int IRQFavoritesDBPrivate::deletePreset(int aUniqId)
{
    TRAPD(err, (mIRFavoritesDb->DeletePresetL(aUniqId)));
    int result = 0;
    IRQUtility::convertSError2QError(err, result);
    return result;
}

int IRQFavoritesDBPrivate::searchPreset(int aUniqPresetId, int aIsdsPresetId)
{
    int returnCode = 0;
    int result = 0; //for QT
    returnCode = mIRFavoritesDb->SearchPreset(aUniqPresetId, aIsdsPresetId);
    IRQUtility::convertSError2QError(returnCode, result);
    return result;
}

int IRQFavoritesDBPrivate::getPreviousPreset(int aIndex)
{
    return mIRFavoritesDb->GetPreviousPreset(aIndex);
}

int IRQFavoritesDBPrivate::getNextPreset(int aIndex)
{
    return mIRFavoritesDb->GetNextPreset(aIndex);
}

int IRQFavoritesDBPrivate::replacePreset(const IRQPreset& aNewPreset)
{
    TRAPD(err, replacePresetL(aNewPreset));
    int result = 0;
    IRQUtility::convertSError2QError(err, result);
    return result;
}

int IRQFavoritesDBPrivate::replaceUserDefinedPreset(const IRQPreset& aNewPreset)
{
    TRAPD(err, replaceUserDefinedPresetL(aNewPreset));
    int result = 0;
    IRQUtility::convertSError2QError(err, result);
    return result;
}

int IRQFavoritesDBPrivate::makePresetUserDefined(int aChannelId, int aUserDefinedChannelId)
{
    TRAPD(err, mIRFavoritesDb->MakePresetUserDefinedL(aChannelId, aUserDefinedChannelId));
    int result = 0;
    IRQUtility::convertSError2QError(err, result);
    return result;
}

int IRQFavoritesDBPrivate::emptyPresetCount() const
{
    return mIRFavoritesDb->EmptyPresetCount();
}

int IRQFavoritesDBPrivate::maxPresetCount()
{
    return mIRFavoritesDb->MaxPresetCount();
}

void IRQFavoritesDBPrivate::setMoveStatus(bool aStatus)
{
    mIRFavoritesDb->SetMoveStatus(aStatus);  
}

bool IRQFavoritesDBPrivate::getMoveStatus()
{
    if (mIRFavoritesDb->GetMoveStatus())
    {
        return true;
    }
    else
    {
        return false;
    }
}

QList<IRQPreset*>* IRQFavoritesDBPrivate::getPresets() const
{
    QList<IRQPreset*> * presetList = new QList<IRQPreset*> ();
    const RIRPresetArray& cirPresetList = mIRFavoritesDb->GetAllSortedPresets();
    int counts = cirPresetList.Count();
    for (int i = 0; i < counts; i++)
    {
        IRQPreset *irqPreset = new IRQPreset();
        IRQUtility::convertCIRPreset2IRQPreset(*(cirPresetList[i]), *irqPreset);
        presetList->append(irqPreset);
    }
    return presetList;
}

void IRQFavoritesDBPrivate::increasePlayedTimes(const IRQPreset &aPreset)
{
    TRAP_IGNORE(increasePlayedTimesL(aPreset));
}

int IRQFavoritesDBPrivate::renamePreset(const IRQPreset &aPreset, const QString &aNewName)
{
    int returnCode = 0;
    TRAPD(err, returnCode = renamePresetL(aPreset, aNewName));
    
    int result = 0;
    if (KErrNone != err)
    {
        IRQUtility::convertSError2QError(err, result);
    }
    else
    {
        IRQUtility::convertSError2QError(returnCode, result);
    }
    return result;
}

/* from MPSPresetObserver */
void IRQFavoritesDBPrivate::HandlePresetChangedL(TInt aId, TUid aDataHandler, MPSPresetObserver::TPSReason aType)
{
    IRQFavoritesDB::PSReason reason = IRQFavoritesDB::PSCreated;
    switch (aType)
    {
    case EPSCreated:
        reason = IRQFavoritesDB::PSCreated;
        break;
        
    case EPSDeleted:
        reason = IRQFavoritesDB::PSDeleted;
        break;
        
    case EPSModified:
        reason = IRQFavoritesDB::PSModified;
        break;
        
    default:
        Q_ASSERT(false);
        break;
    }
    
    emit q_ptr->presetChanged(aId, aDataHandler.iUid, reason);
}

void IRQFavoritesDBPrivate::addPresetL(const IRQPreset& aPreset, int& aRetValue)
{
    CIRIsdsPreset * cirPreset = CIRIsdsPreset::NewLC();
    IRQUtility::convertIRQPreset2CIRIsdsPreset(aPreset, *cirPreset);
    mIRFavoritesDb->AddPresetL(*cirPreset, aRetValue);
    CleanupStack::PopAndDestroy(cirPreset);
}

void IRQFavoritesDBPrivate::replacePresetL(const IRQPreset& aNewPreset)
{
    CIRIsdsPreset * cirPreset = CIRIsdsPreset::NewLC();
    IRQUtility::convertIRQPreset2CIRIsdsPreset(aNewPreset, *cirPreset);
    mIRFavoritesDb->ReplacePresetL(*cirPreset);
    CleanupStack::PopAndDestroy(cirPreset);
}

void IRQFavoritesDBPrivate::replaceUserDefinedPresetL(const IRQPreset& aNewPreset)
{
    CIRIsdsPreset *cirPreset = CIRIsdsPreset::NewLC();
    IRQUtility::convertIRQPreset2CIRIsdsPreset(aNewPreset, *cirPreset);
    mIRFavoritesDb->ReplaceUserDefinedPresetL(*cirPreset);
    CleanupStack::PopAndDestroy(cirPreset);
}

void IRQFavoritesDBPrivate::increasePlayedTimesL(const IRQPreset &aPreset)
{
    CIRIsdsPreset * cirPreset = CIRIsdsPreset::NewLC();
    IRQUtility::convertIRQPreset2CIRIsdsPreset(aPreset, *cirPreset);
    mIRFavoritesDb->IncreasePlayedTimesL(*cirPreset);    
    CleanupStack::PopAndDestroy(cirPreset);
}

int IRQFavoritesDBPrivate::renamePresetL(const IRQPreset &aPreset, const QString &aNewName)
{
    CIRIsdsPreset * cirPreset = CIRIsdsPreset::NewLC();
    IRQUtility::convertIRQPreset2CIRIsdsPreset(aPreset, *cirPreset);
    TPtrC newName(reinterpret_cast<const TUint16*>(aNewName.utf16()), aNewName.length());
    int ret = mIRFavoritesDb->RenamePresetL(*cirPreset, newName);
    CleanupStack::PopAndDestroy(cirPreset);
    
    return ret;
}