//////////////////////////////////

// Qt docs: It is up to the application that requests the data to delete the QIODevice when done with it.
QIODevice* AssetCache::data(const QUrl &url)
{
    QFile *dataFile = 0;
    QString absoluteDataFile = GenerateFilename(false, url);
    if (QFile::exists(absoluteDataFile))
        dataFile = new QFile(absoluteDataFile, this); // still set parent for app close
    return dataFile;
}

void AssetCache::insert(QIODevice* device)
{
    // We own this from prepare(), lets delete it also
    device->close();
    device->deleteLater();
}

QIODevice* AssetCache::prepare(const QNetworkCacheMetaData &metaData)
{
    if (!WriteMetadata(GenerateFilename(true, metaData.url()), metaData))
        return 0;
    QFile *dataFile = new QFile(GenerateFilename(false, metaData.url()), this);
    return dataFile;
}

bool AssetCache::remove(const QUrl &url)
{
    bool success = true;
    QString absoluteMetaDataFile = GenerateFilename(true,url);
    if (QFile::exists(absoluteMetaDataFile))
        success = QFile::remove(absoluteMetaDataFile);
    if (!success)
        return false;
    QString absoluteDataFile = GenerateFilename(false, url);
    if (QFile::exists(absoluteDataFile))
        success = QFile::remove(absoluteDataFile);
    return success;
}

QNetworkCacheMetaData AssetCache::metaData(const QUrl &url)
{
    QNetworkCacheMetaData resultMetaData;
    QString absoluteMetaDataFile = GenerateFilename(true, url);
    if (QFile::exists(absoluteMetaDataFile))
    {
        QFile metaDataFile(absoluteMetaDataFile);
        if (metaDataFile.open(QIODevice::ReadOnly))
        {
            QDataStream metaDataStream(&metaDataFile);
            metaDataStream >> resultMetaData;
            metaDataFile.close();
        }
    }
    return resultMetaData;
}

void AssetCache::updateMetaData(const QNetworkCacheMetaData &metaData)
{
    const QNetworkCacheMetaData oldMetaData = this->metaData(metaData.url());
    if (oldMetaData != metaData)
    {
        WriteMetadata(GenerateFilename(true, metaData.url()), metaData);
    }
}

bool AssetCache::WriteMetadata(const QString &filePath, const QNetworkCacheMetaData &metaData)
{
    // Open metadata file
    QFile metaDataFile(filePath);
    if (!metaDataFile.open(QIODevice::WriteOnly))
    {
        LogError("AssetCache: Could not open metadata file: " + filePath.toStdString());
        return false;
    }
    if (!metaDataFile.resize(0))
    {
        LogError("AssetCache: Could not reset metadata file: " + filePath.toStdString());
        return false;
    }

    // Write metadata
    QDataStream metaDataStream(&metaDataFile);
    metaDataStream << metaData;
    metaDataFile.close();
    return true;
}

QString AssetCache::GenerateFilename(bool isMetaData, const QUrl &url)
{
    QString subDir = isMetaData ? "metadata/" : "data/";
    QDir assetDir(cacheDirectory + subDir);
    QString absolutePath = assetDir.absolutePath() + SanitateAssetRefForCache(url.toString())
    if (isMetaData)
        absolutePath.append(".metadata");
    return absolutePath;
}

void AssetCache::clear()
{
    LogInfo("AssetCache: clear() called, removing all cache items.");
    // Skip for now
}

qint64 AssetCache::expire()
{
    // Skip keeping cache at some static size, unlimited for now
    return maximumCacheSize() / 2;
}

//////////////////////////////////