/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <fs_cache.h>

#include <new>

#include "AutoDeleter.h"
#include "Debug.h"

#include "../kernel_emu.h"


struct FileCache {
        dev_t   mountID;
        ino_t   vnodeID;
        bool    enabled;

        FileCache(dev_t mountID, ino_t vnodeID)
                :
                mountID(mountID),
                vnodeID(vnodeID),
                enabled(true)
        {
        }
};


void*
file_cache_create(dev_t mountID, ino_t vnodeID, off_t size)
{
        PRINT(("file_cache_create(%" B_PRIdDEV ", %" B_PRIdINO ", %"
                B_PRIdOFF ")\n", mountID, vnodeID, size));

        // create the client-side object
        FileCache* fileCache = new(std::nothrow) FileCache(mountID, vnodeID);
        if (fileCache == NULL)
                return NULL;
        ObjectDeleter<FileCache> cacheDeleter(fileCache);

        // create the kernel-size file cache
        status_t error = UserlandFS::KernelEmu::file_cache_create(mountID, vnodeID,
                size);
        if (error != B_OK) {
                REPORT_ERROR(error);
                return NULL;
        }

        cacheDeleter.Detach();

        PRINT(("file_cache_create() -> %p\n", fileCache));
        return fileCache;
}


void
file_cache_delete(void *cacheRef)
{
        if (cacheRef == NULL)
                return;

        PRINT(("file_cache_delete(%p)\n", cacheRef));

        FileCache* fileCache = (FileCache*)cacheRef;

        UserlandFS::KernelEmu::file_cache_delete(fileCache->mountID,
                fileCache->vnodeID);

        delete fileCache;
}


void
file_cache_enable(void *cacheRef)
{
        PRINT(("file_cache_enable(%p)\n", cacheRef));

        FileCache* fileCache = (FileCache*)cacheRef;

        if (fileCache->enabled)
                return;

        if (UserlandFS::KernelEmu::file_cache_set_enabled(fileCache->mountID,
                        fileCache->vnodeID, true) == B_OK) {
                fileCache->enabled = true;
        }
}


bool
file_cache_is_enabled(void *cacheRef)
{
        FileCache* fileCache = (FileCache*)cacheRef;

        return fileCache->enabled;
}


status_t
file_cache_disable(void *cacheRef)
{
        PRINT(("file_cache_disable(%p)\n", cacheRef));

        FileCache* fileCache = (FileCache*)cacheRef;

        if (!fileCache->enabled)
                return B_OK;

        status_t error = UserlandFS::KernelEmu::file_cache_set_enabled(
                fileCache->mountID, fileCache->vnodeID, false);
        if (error == B_OK)
                fileCache->enabled = false;

        return error;
}


status_t
file_cache_set_size(void *cacheRef, off_t size)
{
        if (cacheRef == NULL)
                return B_BAD_VALUE;

        PRINT(("file_cache_set_size(%p)\n", cacheRef));

        FileCache* fileCache = (FileCache*)cacheRef;

        return UserlandFS::KernelEmu::file_cache_set_size(fileCache->mountID,
                fileCache->vnodeID, size);
}


status_t
file_cache_sync(void *cacheRef)
{
        if (cacheRef == NULL)
                return B_BAD_VALUE;

        PRINT(("file_cache_sync(%p)\n", cacheRef));

        FileCache* fileCache = (FileCache*)cacheRef;

        return UserlandFS::KernelEmu::file_cache_sync(fileCache->mountID,
                fileCache->vnodeID);
}


status_t
file_cache_read(void *cacheRef, void *cookie, off_t offset, void *bufferBase,
        size_t *_size)
{
        PRINT(("file_cache_read(%p, %p, %" B_PRIdOFF ", %p, %lu)\n",
                cacheRef, cookie, offset, bufferBase, *_size));

        FileCache* fileCache = (FileCache*)cacheRef;

        return UserlandFS::KernelEmu::file_cache_read(fileCache->mountID,
                fileCache->vnodeID, cookie, offset, bufferBase, _size);
}


status_t
file_cache_write(void *cacheRef, void *cookie, off_t offset, const void *buffer,
        size_t *_size)
{
        PRINT(("file_cache_write(%p, %p, %" B_PRIdOFF ", %p, %lu)\n",
                cacheRef, cookie, offset, buffer, *_size));

        FileCache* fileCache = (FileCache*)cacheRef;

        return UserlandFS::KernelEmu::file_cache_write(fileCache->mountID,
                fileCache->vnodeID, cookie, offset, buffer, _size);
}