/**
   This file is part of CWRT package **

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

   This program 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, version 2.1 of the License. 
   This program 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 program. If not, see <http://www.gnu.org/licenses/>.
*/

#include "clientdownload.h"
#include "downloadmanager.h"
#include "downloadbackend.h"
#include "downloadcore.h"
#include "downloadfactory.h"
#include "downloadstore.h"
#include <QCoreApplication>
#include <QDateTime>

//private implementation
class DownloadBackendPrivate
{
    DM_DECLARE_PUBLIC(DownloadBackend);
public:
    DownloadBackendPrivate();
    ~DownloadBackendPrivate();

    DownloadCore *m_downloadCore; // not owned
    ClientDownload *m_download; //// not owned, only reference 
    DownloadInfo *m_dlInfo; // not owned
    qint64 m_totalSize; // total size of the download
    qint64 m_currentDownloadedSize; // current downloaded size
    qint64 m_lastPausedSize;
    DownloadState m_downloadState; // state of the download
    bool m_infoDeleted; // flag to indicate the info deletion    
    QDateTime m_startTime; // download start/resumed time
    QDateTime m_endTime; // download completed time
    int m_progressCounter;
};  

DownloadBackendPrivate::DownloadBackendPrivate()
{
    m_downloadCore = 0;
    m_download = 0;
    m_dlInfo = 0;
    m_totalSize = 0;
    m_currentDownloadedSize = 0;
    m_lastPausedSize =0;
    m_infoDeleted = false;
    m_progressCounter = 1;
}

DownloadBackendPrivate::~DownloadBackendPrivate()
{
#if 0 //m_downloadCore may be stale.
    if(m_downloadCore)
    {     
        // cancel if there is any transaction
        m_downloadCore->abort();
    }
#endif
}

DownloadBackend::DownloadBackend(DownloadCore *dlCore, ClientDownload* dl)
{
    DM_INITIALIZE(DownloadBackend);
    priv->m_downloadCore = dlCore;
    priv->m_download = dl;
    priv->m_dlInfo = dl->downloadInfo();
    // connect all the signals from network
    connect(dlCore, SIGNAL(downloadProgress(qint64 , qint64 )), this, SLOT(bytesRecieved(qint64 , qint64 )));
    connect(dlCore, SIGNAL(finished()), this, SLOT(handleFinished()));
    connect(dlCore, SIGNAL(metaDataChanged()), this, SLOT(headerReceived()));
    connect(dlCore, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error(QNetworkReply::NetworkError)));
    connect(dlCore, SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(bytesUploaded(qint64, qint64)));

    // save the content type and url
    setValue(DownloadInfo::EContentType, priv->m_downloadCore->contentType()); 
    setValue(DownloadInfo::EUrl, priv->m_downloadCore->url()); 
    setValue(DownloadInfo::EETag, priv->m_downloadCore->entityTag());
    postEvent(Started, NULL);
}

DownloadBackend::~DownloadBackend()
{
    DM_UNINITIALIZE(DownloadBackend);
}

int DownloadBackend::pause()
{
    DM_PRIVATE(DownloadBackend);
    setDownloadState(DlPaused);
    priv->m_downloadCore->abort();
    return 0;
}

int DownloadBackend::resume()
{
    DM_PRIVATE(DownloadBackend);
    setDownloadState(DlInprogress);
    // save the content type and url
    setValue(DownloadInfo::EUrl, priv->m_downloadCore->url());
    setValue(DownloadInfo::EContentType, priv->m_downloadCore->contentType());
    priv->m_lastPausedSize = priv->m_currentDownloadedSize;
    priv->m_downloadCore->resumeDownload(priv->m_currentDownloadedSize);
    priv->m_startTime = QDateTime::currentDateTime();
    postEvent(Progress, NULL);
    return 0;
}

int DownloadBackend::cancel()
{
    DM_PRIVATE(DownloadBackend);   
    setDownloadState(DlCancelled);
    // cancel the transaction
    priv->m_downloadCore->abort();
    // delete the temporary storage
    deleteStore();
    // reset the states
    priv->m_totalSize = 0;
    priv->m_currentDownloadedSize = 0;
    priv->m_lastPausedSize = 0;
    return 0;
}

QVariant DownloadBackend::getAttribute(DownloadAttribute attr)
{
    DM_PRIVATE(DownloadBackend); 
    switch(attr)
    {
         case DlDownloadedSize:
         {
             return QVariant(priv->m_currentDownloadedSize);
         }
         case DlTotalSize:
         {
             return QVariant(priv->m_totalSize);
         }
         case DlDownloadState:
         {
             return QVariant(priv->m_downloadState);
         }
         case DlSourceUrl:
         {
             return QVariant(priv->m_downloadCore->url());
         }
         case DlContentType:
         {
             return QVariant(priv->m_downloadCore->contentType());
         }
         case DlStartTime:
         {
             return QVariant(priv->m_startTime);
         }
         case DlEndTime:
         {
             if (priv->m_downloadState == DlCompleted)
                 return priv->m_endTime;
             else 
                 return QVariant();
         }
         case DlElapsedTime:
         {
             if (priv->m_downloadState == DlCompleted)
                 return QVariant((priv->m_endTime.toTime_t()-priv->m_startTime.toTime_t()));

             if (priv->m_downloadState != DlInprogress)
                 return QVariant();
             QDateTime currentTime = QDateTime::currentDateTime();
             uint timeElasped = currentTime.toTime_t() - priv->m_startTime.toTime_t();
             return QVariant(timeElasped);
         }
         case DlRemainingTime:
         {
             if (priv->m_downloadState != DlInprogress)
                 return QVariant();
             QDateTime currentTime = QDateTime::currentDateTime();
             uint timeElasped = currentTime.toTime_t() - priv->m_startTime.toTime_t();
             // total bytes recieved since last start/resume
             qint64 totalBytesRecieved = priv->m_currentDownloadedSize - priv->m_lastPausedSize;
             qint64 remainingSize = priv->m_totalSize - priv->m_currentDownloadedSize;
             if (totalBytesRecieved > 0)
                 return QVariant((timeElasped*remainingSize)/totalBytesRecieved);
             else
                 return QVariant();
         }
         case DlSpeed:
         {
             if (priv->m_downloadState != DlInprogress)
                 return QVariant();
             QDateTime currentTime = QDateTime::currentDateTime();
             uint timeElasped = currentTime.toTime_t() - priv->m_startTime.toTime_t();
             qint64 totalBytesRecieved = priv->m_currentDownloadedSize - priv->m_lastPausedSize;
             if (timeElasped > 0)
                 return QVariant(totalBytesRecieved/timeElasped);
             else
                 return QVariant();
         }
         case DlPercentage:
         {
             if (priv->m_totalSize > 0)
                 return QVariant((priv->m_currentDownloadedSize*100)/priv->m_totalSize);
             else
                 return QVariant();
         }
         case DlLastError:
         {
             return QVariant(priv->m_downloadCore->lastError());
         }
         case DlLastErrorString:
         {
             return QVariant(priv->m_downloadCore->lastErrorString());
         }
         default:
         {
             break;
         }
     }
    return QVariant();
     
}

int DownloadBackend::setAttribute(DownloadAttribute /*attr*/, const QVariant& /*value*/)
{
    return -1;
}

void DownloadBackend::bytesRecieved(qint64 bytesRecieved, qint64 bytesTotal)
{
    DM_PRIVATE(DownloadBackend);
    if((priv->m_downloadState == DlFailed) || (bytesRecieved == 0))
    {
        return;
    }
 
    // in case of resumed downloads, we recieve total size remained to download
    setTotalSize(priv->m_lastPausedSize + bytesTotal);
    priv->m_currentDownloadedSize = priv->m_lastPausedSize + bytesRecieved;
    setDownloadState(DlInprogress);
    // store the recieved chunk
    store(priv->m_downloadCore->reply()->readAll(), false); 
    postEvent(Progress, NULL);
}

void DownloadBackend::handleFinished()
{
    DM_PRIVATE(DownloadBackend);

    DownloadState state = priv->m_downloadState;
    if( state == DlFailed )
    {
        postEvent(Failed, NULL);  
        return;
    }
    if( state == DlPaused )
    {
        postEvent(Paused, NULL);  
        return;
    }
    if( state == DlCancelled )
    {
        postEvent(Cancelled, NULL);  
        return;
    }
    if(priv->m_currentDownloadedSize < priv->m_totalSize)
    {
        // all packets are not recieved, so it is not last chunk 
        // should be some network problem
        store(priv->m_downloadCore->reply()->readAll(), false); 
        postEvent(NetworkLoss, NULL);
    }
    else
    {
        //finish is successful
        store(priv->m_downloadCore->reply()->readAll(), true);
        //finish is successful
        setDownloadState(DlCompleted);
        priv->m_endTime = QDateTime::currentDateTime();
        postEvent(Completed, NULL);
    } 
}

void DownloadBackend::error(QNetworkReply::NetworkError code)
{
    DM_PRIVATE(DownloadBackend);
    if((code == QNetworkReply::OperationCanceledError) && (priv->m_downloadState == DlCancelled))
    { 
        return;
    }   
    if(code == QNetworkReply::OperationCanceledError) 
    {
        // this means user has paused the download
        setDownloadState(DlPaused);
    }   
    else if(code != QNetworkReply::NoError)
    {
        priv->m_downloadCore->setLastError(code);
        if(priv->m_downloadCore->reply())
        {
            priv->m_downloadCore->setLastErrorString(priv->m_downloadCore->reply()->errorString());
        }
        setDownloadState(DlFailed);
        postEvent(Error, NULL);
    }
}

void DownloadBackend::postEvent(DEventType type, DlEventAttributeMap* attrMap)
{
    DM_PRIVATE(DownloadBackend);
    // The client if it doesn't want progress events then it can set the DownloadMgrProgress mode as quiet
    // If it wants progress events at regular intervals then it has to specify the KiloBytes at which it requires the progress event.
    // By default, the DownloadMgrProgress Mode is non-quiet with progress events being sent at every 5KB downloaded. 
    DownloadMgrProgressMode mode = (DownloadMgrProgressMode)(priv->m_download->downloadManager()->getAttribute(DlMgrProgressMode)).toInt();
    if ((mode == Quiet) && (type == Progress))
        return;

    qlonglong kBytes = priv->m_download->getAttribute(DlProgressInterval).toLongLong() * 1024;
    if (mode == NonQuiet && type == Progress)
    {
        if ((priv->m_currentDownloadedSize/(kBytes * priv->m_progressCounter)) > 0)
        {
            priv->m_progressCounter++;
            postDownloadEvent(type, attrMap);
        }
    }
    else
        postDownloadEvent(type, attrMap);
}

DownloadState DownloadBackend::downloadState(void)
{
    DM_PRIVATE(DownloadBackend);
    return priv->m_downloadState;
}

void DownloadBackend::setDownloadState(DownloadState state)
{
    DM_PRIVATE(DownloadBackend);
    priv->m_downloadState = state;
    // save the download state
    setValue(DownloadInfo::EDlState, priv->m_downloadState);
    if((state == DlFailed) || (state == DlCompleted) || (state == DlCancelled))
    {
        // remove dl info
            deleteInfo();
    }
}

void DownloadBackend::setDownloadedDataSize(qint64 size)
{
    DM_PRIVATE(DownloadBackend);
    priv->m_currentDownloadedSize = size;
    return;
}

void DownloadBackend::setTotalSize(qint64 size)
{
    DM_PRIVATE(DownloadBackend);
    priv->m_totalSize = size;
    setValue(DownloadInfo::ETotalSize, priv->m_totalSize);
    return;
}

void DownloadBackend::setStartTime()
{
    DM_PRIVATE(DownloadBackend);
    priv->m_startTime = QDateTime::currentDateTime();
}

ClientDownload* DownloadBackend::download(void)
{
    DM_PRIVATE(DownloadBackend);
    return priv->m_download;
}

/* Helper functions to access download info */

int DownloadBackend::setValue(DownloadInfo::Key aKey, const QString& aStrValue)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->setValue(priv->m_download->id(), aKey, aStrValue, priv->m_download->parentId());
}

int DownloadBackend::setValueForChild(DownloadInfo::Key aKey, const QString& aStrValue, int aChildId)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->setValueForChild(priv->m_download->id(), aKey, aStrValue, aChildId);
}

int DownloadBackend::setValue(DownloadInfo::Key aKey, long aIntValue)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->setValue(priv->m_download->id(), aKey, aIntValue, priv->m_download->parentId());
}

int DownloadBackend::setValueForChild(DownloadInfo::Key aKey, long aIntValue, int aChildId)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->setValueForChild(priv->m_download->id(), aKey, aIntValue, aChildId);
}

int DownloadBackend::setValue(DownloadInfo::Key aKey, const QList<QVariant>& aChildIds)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->setValue(priv->m_download->id(), aKey, aChildIds);
}

int DownloadBackend::getValue(DownloadInfo::Key aKey, QString& aStrValue)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->getValue(priv->m_download->id(), aKey, aStrValue, priv->m_download->parentId());
}

int DownloadBackend::getValueForChild(DownloadInfo::Key aKey, QString& aStrValue, int aChildId)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->getValueForChild(priv->m_download->id(), aKey, aStrValue, aChildId);
}

int DownloadBackend::getValue(DownloadInfo::Key aKey, long& aIntValue)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->getValue(priv->m_download->id(), aKey, aIntValue, priv->m_download->parentId());
}

int DownloadBackend::getValueForChild(DownloadInfo::Key aKey, long& aIntValue, int aChildId)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->getValueForChild(priv->m_download->id(), aKey, aIntValue, aChildId);
 
}

int DownloadBackend::getValue(DownloadInfo::Key aKey, QList<QVariant>& aChildIds)
{
    DM_PRIVATE(DownloadBackend);
    if(priv->m_infoDeleted)
        return 0;
    return priv->m_dlInfo->getValue(priv->m_download->id(), aKey, aChildIds);
}

int DownloadBackend::deleteInfo()
{
    DM_PRIVATE(DownloadBackend);
    if ((InActive == priv->m_download->downloadManager()->getAttribute(DlMgrPersistantMode))
        && (DlCompleted == priv->m_downloadState))
        return 0;
    priv->m_infoDeleted = true;
    return priv->m_dlInfo->remove(priv->m_download->id(), priv->m_download->parentId()); 
}
void DownloadBackend::postDownloadEvent(DEventType type, DlEventAttributeMap* attrMap)
{
    DM_PRIVATE(DownloadBackend);
    EventReceiverList list = priv->m_download->eventReceivers();
    for(int i=0; i<list.size(); i++)
    {
        if(list[i])
        {
            DownloadEvent *event = new DownloadEvent(type, attrMap, priv->m_download->id());
            QCoreApplication::postEvent(list[i], event);
        }
    }
}