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

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

#include <disk_device_manager.h>
#include <fs_cache.h>
#include <fs_interface.h>
#include <io_requests.h>
#include <KernelExport.h>
#include <NodeMonitor.h>

#include <fs/node_monitor.h>

#include "Debug.h"

#include "../FileSystem.h"
#include "../IORequestInfo.h"
#include "../kernel_emu.h"
#include "../RequestThread.h"

#include "HaikuKernelIORequest.h"
#include "HaikuKernelNode.h"
#include "HaikuKernelVolume.h"
#include "vfs.h"


// When GCC 2 compiles inline functions in debug mode, it doesn't throw away
// the generated non-inlined functions, if they aren't used. So we have to
// provide the dependencies referenced by inline functions in private kernel
// headers.
#if __GNUC__ == 2

#include <cpu.h>
#include <smp.h>

cpu_ent gCPU[1];


int32
smp_get_current_cpu(void)
{
        return 0;
}


#endif  // __GNUC__ == 2


// #pragma mark - Notifications


// notify_entry_created
status_t
notify_entry_created(dev_t device, ino_t directory, const char *name,
        ino_t node)
{
        if (!name)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_listener(B_ENTRY_CREATED, 0, device, 0,
                directory, node, NULL, name);
}


// notify_entry_removed
status_t
notify_entry_removed(dev_t device, ino_t directory, const char *name,
        ino_t node)
{
        if (!name)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_listener(B_ENTRY_REMOVED, 0, device, 0,
                directory, node, NULL, name);
}


// notify_entry_moved
status_t
notify_entry_moved(dev_t device, ino_t fromDirectory,
        const char *fromName, ino_t toDirectory, const char *toName,
        ino_t node)
{
        if (!fromName || !toName)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_listener(B_ENTRY_MOVED, 0, device,
                fromDirectory, toDirectory, node, fromName, toName);
}


// notify_stat_changed
status_t
notify_stat_changed(dev_t device, ino_t directory, ino_t node,
        uint32 statFields)
{
        return UserlandFS::KernelEmu::notify_listener(B_STAT_CHANGED, statFields,
                device, 0, directory, node, NULL, NULL);
}


// notify_attribute_changed
status_t
notify_attribute_changed(dev_t device, ino_t directory, ino_t node,
        const char *attribute, int32 cause)
{
        if (!attribute)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_listener(B_ATTR_CHANGED, cause,
                device, 0, directory, node, NULL, attribute);
}


// notify_select_event
status_t
notify_select_event(selectsync *sync, uint8 event)
{
        return UserlandFS::KernelEmu::notify_select_event(sync, event, false);
}


// notify_query_entry_created
status_t
notify_query_entry_created(port_id port, int32 token, dev_t device,
        ino_t directory, const char *name, ino_t node)
{
        if (!name)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_query(port, token, B_ENTRY_CREATED,
                device, directory, name, node);
}


// notify_query_entry_removed
status_t
notify_query_entry_removed(port_id port, int32 token, dev_t device,
        ino_t directory, const char *name, ino_t node)
{
        if (!name)
                return B_BAD_VALUE;

        return UserlandFS::KernelEmu::notify_query(port, token, B_ENTRY_REMOVED,
                device, directory, name, node);
}


// #pragma mark - VNodes


// new_vnode
status_t
new_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode,
        fs_vnode_ops *ops)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        // translate to a wrapper node
        HaikuKernelNode* node;
        status_t error = volume->NewVNode(vnodeID, privateNode, ops, &node);
        if (error != B_OK)
                return error;

        // announce the new node
        error = UserlandFS::KernelEmu::new_vnode(volume->GetID(), vnodeID, node,
                node->capabilities->capabilities);
        if (error != B_OK)
                volume->UndoNewVNode(node);

        return error;
}


// publish_vnode
status_t
publish_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode,
        fs_vnode_ops *ops, int type, uint32 flags)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        // translate to a wrapper node
        HaikuKernelNode* node;
        status_t error = volume->PublishVNode(vnodeID, privateNode, ops, type,
                flags, &node);
        if (error != B_OK)
                return error;

        // publish the new node
        error = UserlandFS::KernelEmu::publish_vnode(volume->GetID(), vnodeID, node,
                type, flags, node->capabilities->capabilities);
        if (error != B_OK)
                volume->UndoPublishVNode(node);

        return error;
}


// get_vnode
status_t
get_vnode(fs_volume *_volume, ino_t vnodeID, void **privateNode)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        // get the node
        void* foundNode;
        status_t error = UserlandFS::KernelEmu::get_vnode(volume->GetID(), vnodeID,
                &foundNode);
        if (error != B_OK)
                return error;

        if (privateNode != NULL)
                *privateNode = ((HaikuKernelNode*)foundNode)->private_node;

        return B_OK;
}


// put_vnode
status_t
put_vnode(fs_volume *_volume, ino_t vnodeID)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        return UserlandFS::KernelEmu::put_vnode(volume->GetID(), vnodeID);
}


// acquire_vnode
status_t
acquire_vnode(fs_volume *_volume, ino_t vnodeID)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        return UserlandFS::KernelEmu::acquire_vnode(volume->GetID(), vnodeID);
}


// remove_vnode
status_t
remove_vnode(fs_volume *_volume, ino_t vnodeID)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        return UserlandFS::KernelEmu::remove_vnode(volume->GetID(), vnodeID);
}


// unremove_vnode
status_t
unremove_vnode(fs_volume *_volume, ino_t vnodeID)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        return UserlandFS::KernelEmu::unremove_vnode(volume->GetID(), vnodeID);
}


// get_vnode_removed
status_t
get_vnode_removed(fs_volume *_volume, ino_t vnodeID, bool* removed)
{
        HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);

        return UserlandFS::KernelEmu::get_vnode_removed(volume->GetID(), vnodeID,
                removed);
}


// volume_for_vnode
fs_volume*
volume_for_vnode(fs_vnode *vnode)
{
        return HaikuKernelNode::GetNode(vnode)->GetVolume()->GetFSVolume();
}


// read_file_io_vec_pages
status_t
read_file_io_vec_pages(int fd, const struct file_io_vec *fileVecs,
        size_t fileVecCount, const struct iovec *vecs, size_t vecCount,
        uint32 *_vecIndex, size_t *_vecOffset, size_t *_bytes)
{
        // TODO: Implement!
        return B_UNSUPPORTED;
}


// write_file_io_vec_pages
status_t
write_file_io_vec_pages(int fd, const struct file_io_vec *fileVecs,
        size_t fileVecCount, const struct iovec *vecs, size_t vecCount,
        uint32 *_vecIndex, size_t *_vecOffset, size_t *_bytes)
{
        // TODO: Implement!
        return B_UNSUPPORTED;
}


// do_fd_io
status_t
do_fd_io(int fd, io_request *request)
{
        // TODO: Implement!
        return B_UNSUPPORTED;
}


// do_iterative_fd_io
status_t
do_iterative_fd_io(int fd, io_request *_request, iterative_io_get_vecs getVecs,
        iterative_io_finished finished, void *_cookie)
{
        HaikuKernelIORequest* request = (HaikuKernelIORequest*)_request;

        // get the first vecs already -- this saves a guaranteed trip back from
        // kernel to userland
        file_io_vec fileVecs[DoIterativeFDIORequest::MAX_VECS];
        size_t fileVecCount = DoIterativeFDIORequest::MAX_VECS;
        status_t error = getVecs(_cookie, _request, request->offset,
                request->length, fileVecs, &fileVecCount);
        if (error != B_OK && error != B_BUFFER_OVERFLOW)
                return error;

        // create a cookie
        HaikuKernelIterativeFDIOCookie* cookie
                = new(std::nothrow) HaikuKernelIterativeFDIOCookie(fd, request, getVecs,
                        finished, _cookie);
        if (cookie == NULL) {
                finished(_cookie, _request, B_NO_MEMORY, false, 0);
                return B_NO_MEMORY;
        }

        // send the request
// TODO: Up to this point we should call the finished hook on error!
        error = UserlandFS::KernelEmu::do_iterative_fd_io(
                request->volume->GetID(), fd, request->id, cookie, fileVecs,
                fileVecCount);
        if (error != B_OK) {
                delete cookie;
                return error;
        }

        return B_OK;
}


// #pragma mark - I/O requests


bool
io_request_is_write(const io_request* request)
{
        return ((HaikuKernelIORequest*)request)->isWrite;
}


bool
io_request_is_vip(const io_request* request)
{
        return ((HaikuKernelIORequest*)request)->isVIP;
}


off_t
io_request_offset(const io_request* request)
{
        return ((HaikuKernelIORequest*)request)->offset;
}


off_t
io_request_length(const io_request* request)
{
        return ((HaikuKernelIORequest*)request)->length;
}


status_t
read_from_io_request(io_request* _request, void* buffer, size_t size)
{
        if (size == 0)
                return B_OK;

        HaikuKernelIORequest* request = (HaikuKernelIORequest*)_request;

        // send the request
        return UserlandFS::KernelEmu::read_from_io_request(request->volume->GetID(),
                request->id, buffer, size);
}


status_t
write_to_io_request(io_request* _request, const void* buffer, size_t size)
{
        HaikuKernelIORequest* request = (HaikuKernelIORequest*)_request;

        // send the request
        return UserlandFS::KernelEmu::write_to_io_request(request->volume->GetID(),
                request->id, buffer, size);
}


void
notify_io_request(io_request* _request, status_t status)
{
        HaikuKernelIORequest* request = (HaikuKernelIORequest*)_request;

        // send the request
        UserlandFS::KernelEmu::notify_io_request(request->volume->GetID(),
                request->id, status);
}


// #pragma mark - node monitoring


status_t
add_node_listener(dev_t device, ino_t node, uint32 flags,
        NotificationListener& listener)
{
        return UserlandFS::KernelEmu::add_node_listener(device, node, flags,
                &listener);
}


status_t
remove_node_listener(dev_t device, ino_t node, NotificationListener& listener)
{
        return UserlandFS::KernelEmu::remove_node_listener(device, node, &listener);
}


// #pragma mark - Disk Device Manager


// get_default_partition_content_name
status_t
get_default_partition_content_name(partition_id partitionID,
        const char* fileSystemName, char* buffer, size_t bufferSize)
{
        // TODO: Improve!
        snprintf(buffer, bufferSize, "%s Volume", fileSystemName);
        return B_OK;
}


// scan_partition
status_t
scan_partition(partition_id partitionID)
{
        // Only needed when we decide to add disk system support.
        return B_OK;
}


// update_disk_device_job_progress
bool
update_disk_device_job_progress(disk_job_id jobID, float progress)
{
        // Only needed when we decide to add disk system support.
        return true;
}


// #pragma mark - VFS private


status_t
vfs_get_file_map(struct vnode *vnode, off_t offset, size_t size,
        struct file_io_vec *vecs, size_t *_count)
{
        HaikuKernelNode* node = (HaikuKernelNode*)vnode;

        return node->volume->GetFileMap(node, offset, size, vecs, _count);
}


status_t
vfs_lookup_vnode(dev_t mountID, ino_t vnodeID, struct vnode **_vnode)
{
        // get the volume
        HaikuKernelVolume* volume = dynamic_cast<HaikuKernelVolume*>(
                FileSystem::GetInstance()->VolumeWithID(mountID));
        if (volume == NULL)
                return B_BAD_VALUE;

        // get the node
        HaikuKernelNode* node = volume->NodeWithID(vnodeID);
        if (node == NULL)
                return B_BAD_VALUE;

        *_vnode = (struct vnode*)node;

        return B_OK;
}