/*
 * Copyright 2017, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

/*!     Shim over the host Haiku fs_attr API */


#ifdef BUILDING_FS_SHELL
#       include "compat.h"
#       define B_OK                                     0
#       define B_BAD_VALUE                      EINVAL
#       define B_FILE_ERROR                     EBADF
#       define B_ERROR                          EINVAL
#       define B_ENTRY_NOT_FOUND        ENOENT
#       define B_NO_MEMORY                      ENOMEM
#else
#       include <syscalls.h>

#       include "fs_impl.h"
#       include "fs_descriptors.h"
#endif

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>

#include <map>
#include <string>

#include <fs_attr.h>


namespace BPrivate {}
using namespace BPrivate;


namespace {

// LocalFD
#include "LocalFD.h"

} // unnamed namspace


// # pragma mark - Public API


// fs_open_attr_dir
extern "C" DIR *
_haiku_build_fs_open_attr_dir(const char *path)
{
        return fs_open_attr_dir(path);
}

// fs_lopen_attr_dir
extern "C" DIR*
_haiku_build_fs_lopen_attr_dir(const char *path)
{
        return fs_lopen_attr_dir(path);
}

// fs_fopen_attr_dir
extern "C" DIR*
_haiku_build_fs_fopen_attr_dir(int fd)
{
        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return NULL;
        }

        if (localFD.FD() < 0) {
                return fs_lopen_attr_dir(localFD.Path());
        } else {
                return fs_fopen_attr_dir(localFD.FD());
        }
}

// fs_close_attr_dir
extern "C" int
_haiku_build_fs_close_attr_dir(DIR *dir)
{
        return fs_close_attr_dir(dir);
}

// fs_read_attr_dir
extern "C" struct dirent *
_haiku_build_fs_read_attr_dir(DIR *dir)
{
        return fs_read_attr_dir(dir);
}

// fs_rewind_attr_dir
extern "C" void
_haiku_build_fs_rewind_attr_dir(DIR *dir)
{
        return fs_rewind_attr_dir(dir);
}

// fs_fopen_attr
extern "C" int
_haiku_build_fs_fopen_attr(int fd, const char *attribute, uint32 type, int openMode)
{
        if (fd < 0) {
                errno = B_BAD_VALUE;
                return -1;
        }

        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return -1;
        }

        if (localFD.FD() < 0) {
                return fs_open_attr(localFD.Path(), attribute, type,
                        openMode | O_NOTRAVERSE);
        } else {
                return fs_fopen_attr(localFD.FD(), attribute, type, openMode);
        }
}

// fs_close_attr
extern "C" int
_haiku_build_fs_close_attr(int fd)
{
        return fs_close_attr(fd);
}

// fs_read_attr
extern "C" ssize_t
_haiku_build_fs_read_attr(int fd, const char* attribute, uint32 type, off_t pos,
        void *buffer, size_t readBytes)
{
        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return -1;
        }

        ssize_t bytesRead;
        if (localFD.FD() < 0) {
                int fd = open(localFD.Path(), O_RDONLY | O_NOTRAVERSE);
                bytesRead = fs_read_attr(fd, attribute, type,
                        pos, buffer, readBytes);
                close(fd);
        } else {
                bytesRead = fs_read_attr(localFD.FD(), attribute, type,
                        pos, buffer, readBytes);
        }
        if (bytesRead < 0) {
                // Make sure, the error code is B_ENTRY_NOT_FOUND, if the attribute
                // doesn't exist.
                if (errno == ENOATTR || errno == ENODATA)
                        errno = B_ENTRY_NOT_FOUND;
                return -1;
        }

        return bytesRead;
}

// fs_write_attr
extern "C" ssize_t
_haiku_build_fs_write_attr(int fd, const char* attribute, uint32 type, off_t pos,
        const void *buffer, size_t writeBytes)
{
        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return -1;
        }

        ssize_t written;
        if (localFD.FD() < 0) {
                int fd = open(localFD.Path(), O_NOTRAVERSE | O_WRONLY);
                written = fs_write_attr(fd, attribute, type,
                        pos, buffer, writeBytes);
                close(fd);
        } else {
                written = fs_write_attr(localFD.FD(), attribute, type,
                        pos, buffer, writeBytes);
        }

        return written;
}

// fs_remove_attr
extern "C" int
_haiku_build_fs_remove_attr(int fd, const char* attribute)
{
        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return -1;
        }

        // remove attribute
        int result;
        if (localFD.FD() < 0) {
                int fd = open(localFD.Path(), O_NOTRAVERSE | O_WRONLY);
                result = fs_remove_attr(fd, attribute);
                close(fd);
        } else {
                result = fs_remove_attr(localFD.FD(), attribute);
        }

        if (result < 0) {
                // Make sure, the error code is B_ENTRY_NOT_FOUND, if the attribute
                // doesn't exist.
                if (errno == ENOATTR || errno == ENODATA)
                        errno = B_ENTRY_NOT_FOUND;
                return -1;
        }
        return 0;
}

// fs_stat_attr
extern "C" int
_haiku_build_fs_stat_attr(int fd, const char *attribute, struct attr_info *attrInfo)
{
        if (!attribute || !attrInfo) {
                errno = B_BAD_VALUE;
                return -1;
        }

        LocalFD localFD;
        status_t error = localFD.Init(fd);
        if (error != B_OK) {
                errno = error;
                return -1;
        }

        int result;
        if (localFD.FD() < 0) {
                int fd = open(localFD.Path(), O_NOTRAVERSE | O_RDONLY);
                result = fs_stat_attr(fd, attribute, attrInfo);
                close(fd);
        } else {
                result = fs_stat_attr(localFD.FD(), attribute, attrInfo);
        }

        return result;
}


// #pragma mark - Private Syscalls


#ifndef BUILDING_FS_SHELL

// _kern_open_attr_dir
int
_kern_open_attr_dir(int fd, const char *path)
{
        // get node ref for the node
        struct stat st;
        status_t error = _kern_read_stat(fd, path, false, &st,
                sizeof(struct stat));
        if (error != B_OK) {
                errno = error;
                return -1;
        }
        NodeRef ref(st);

        DIR* dir;
        if (path) {
                // If a path was given, get a usable path.
                string realPath;
                status_t error = get_path(fd, path, realPath);
                if (error != B_OK)
                        return error;

                dir = _haiku_build_fs_open_attr_dir(realPath.c_str());
        } else
                dir = _haiku_build_fs_fopen_attr_dir(fd);

        if (!dir)
                return errno;

        // create descriptor
        AttrDirDescriptor *descriptor = new AttrDirDescriptor(dir, ref);
        return add_descriptor(descriptor);
}

// _kern_rename_attr
status_t
_kern_rename_attr(int fromFile, const char *fromName, int toFile,
        const char *toName)
{
        // not supported ATM
        return B_BAD_VALUE;
}

// _kern_remove_attr
status_t
_kern_remove_attr(int fd, const char *name)
{
        if (!name)
                return B_BAD_VALUE;

        if (_haiku_build_fs_remove_attr(fd, name) < 0)
                return errno;
        return B_OK;
}

#endif  // ! BUILDING_FS_SHELL