/****************************************************************************
**
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 *
 * This file is part of Qt Web Runtime.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * version 2.1 as published by the Free Software Foundation.
 *
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */

#ifndef FEATHERWEIGHTCACHE_P_H
#define FEATHERWEIGHTCACHE_P_H

#include <QBuffer>
#include <QHash>
#include <QTemporaryFile>
#include <QFile>
#include <QNetworkCacheMetaData>
#include <QObject>
#include <QQueue>
#include <QMutex>
#include <QWaitCondition>
#include <cacheworkerthread.h>

namespace WRT {
class CacheItem
{
public:
    CacheItem() : file(0)
    {
    }
    ~CacheItem()
    {
        reset();
    }

    QNetworkCacheMetaData metaData;
    QBuffer data;
    QTemporaryFile *file;
    inline qint64 size() const
        { return file ? file->size() : data.size(); }

    inline void reset() {
        metaData = QNetworkCacheMetaData();
        data.close();
        delete file;
        file = 0;
    }
    void writeHeader(QFile *device) const;
    void writeCompressedData(QFile *device) const;
    bool read(QFile *device, bool readData);

    bool canCompress() const;
};


class WorkerThread : public QThread
{

    Q_OBJECT

public:
    WorkerThread();
    ~WorkerThread();

    void expireLazily(QString cacheDir, qint64 maxCacheSize);

protected:
    void run();

private:
    QMutex mutex;
    QWaitCondition condition;
    bool abort;
    qint64 expireImpl();

    QString cacheDir;
    qint64 maxCacheSize;

signals:
    void onDiskSizeChanged(qint64 newSize);

};


#define URL2HASH(url) FeatherWeightCachePrivate::generateId(url).toUInt()

// Assume this much higher physical disk usage. Platform and media dependent
// TODO: On Symbian, we could instead round up number to multiple of TVolumeIOParamInfo.iClusterSize
#define FILESYSTEMOVERHEAD 2048
#define ROUNDUPTOMULTIPLE(x, multipleof)    ( (x + multipleof - 1) & ~(multipleof - 1) )

class FeatherWeightCachePrivate : public QObject
{
    Q_OBJECT

public:
    FeatherWeightCachePrivate(QObject* parent): QObject(parent)
        , maximumCacheSize(1024 * 1024 * 10) //set the maximum default cache to 10M 
        , currentCacheSize(-1)
    {
        // Queued connection because onDiskSizeChanged() is currently always triggered from run() method of worker thread
        QObject::connect( &beastOfBurden, SIGNAL( onDiskSizeChanged(qint64) ), this, SLOT( updateCacheSize(qint64) ), Qt::DirectConnection );
    }

    ~FeatherWeightCachePrivate()
    {
        // When beastOfBurden's d'tor is called
        // it will wait() and then auto-terminate

        QObject::disconnect(&beastOfBurden, SIGNAL( onDiskSizeChanged(qint64) ), this, SLOT( updateCacheSize(qint64)));
    }

    qint64 expire();
    static QByteArray generateId(const QUrl &url);
    QString cacheFileName(const QUrl &url) const;
    QString tmpCacheFileName() const;
    bool removeFile(const QString &file);
    void storeItem(CacheItem *item);
    void prepareLayout();
    static quint32 crc32(const char *data, uint len);

    mutable CacheItem lastItem;
    QString cacheDirectory;
    qint64 maximumCacheSize;
    qint64 currentCacheSize;

    QHash<QIODevice*, CacheItem*> inserting;

    WorkerThread beastOfBurden;

    // a look up table (LUT) that stores file sizes
    // corresponding to cached URLs. Helps speed up
    // cache eviction or expiration logic.
    // key = CRC32 hash of url , value = size of file on disk
    // QHash<quint32, qint64> lut;

    // bool isTrimPending;

    //Recommended buffer sizes for fast IO on caching volume
    struct {
        quint32 readBufSize;
        quint32 writeBufSize;
        quint32 clusterSize;
    } volumeInfo;

public slots:
    void updateCacheSize(qint64);
};
}

#endif // FEATHERWEIGHTCACHE_P_H