// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <fuchsia/io/c/fidl.h>
#include <lib/zx/channel.h>
#include <lib/zxio/inception.h>
#include <lib/zxio/null.h>
#include <lib/zxio/ops.h>
#include <string.h>
#include <zircon/syscalls.h>

#define ZXIO_REMOTE_CHUNK_SIZE 8192

static zx_status_t zxio_remote_close(zxio_t* io) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_NodeClose(rio->control, &status);
    zx_handle_t control = rio->control;
    rio->control = ZX_HANDLE_INVALID;
    zx_handle_close(control);
    if (rio->event != ZX_HANDLE_INVALID) {
        zx_handle_t event = rio->event;
        rio->event = ZX_HANDLE_INVALID;
        zx_handle_close(event);
    }
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_release(zxio_t* io, zx_handle_t* out_handle) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_handle_t control = rio->control;
    rio->control = ZX_HANDLE_INVALID;
    if (rio->event != ZX_HANDLE_INVALID) {
        zx_handle_t event = rio->event;
        rio->event = ZX_HANDLE_INVALID;
        zx_handle_close(event);
    }
    *out_handle = control;
    return ZX_OK;
}

static zx_status_t zxio_remote_clone(zxio_t* io, zx_handle_t* out_handle) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx::channel local, remote;
    zx_status_t status = zx::channel::create(0, &local, &remote);
    if (status != ZX_OK) {
        return status;
    }
    uint32_t flags = fuchsia_io_CLONE_FLAG_SAME_RIGHTS;
    status = fuchsia_io_NodeClone(rio->control, flags, remote.release());
    if (status != ZX_OK) {
        return status;
    }
    *out_handle = local.release();
    return ZX_OK;
}

static zx_status_t zxio_remote_sync(zxio_t* io) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_NodeSync(rio->control, &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_attr_get(zxio_t* io, zxio_node_attr_t* out_attr) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_NodeGetAttr(rio->control, &status, out_attr);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_attr_set(zxio_t* io, uint32_t flags, const zxio_node_attr_t* attr) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_NodeSetAttr(rio->control, flags, attr, &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_read_once(zxio_remote_t* rio, uint8_t* buffer,
                                         size_t capacity, size_t* out_actual) {
    size_t actual = 0u;
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileRead(rio->control, capacity, &status,
                                    buffer, capacity, &actual);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (actual > capacity) {
        return ZX_ERR_IO;
    }
    *out_actual = actual;
    return ZX_OK;
}

static zx_status_t zxio_remote_read(zxio_t* io, void* data, size_t capacity,
                                    size_t* out_actual) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    uint8_t* buffer = static_cast<uint8_t*>(data);
    size_t received = 0;
    while (capacity > 0) {
        size_t chunk = (capacity > ZXIO_REMOTE_CHUNK_SIZE) ? ZXIO_REMOTE_CHUNK_SIZE : capacity;
        size_t actual = 0;
        zx_status_t status = zxio_remote_read_once(rio, buffer, chunk, &actual);
        if (status != ZX_OK) {
            return status;
        }
        received += actual;
        buffer += actual;
        capacity -= actual;
        if (chunk != actual) {
            break;
        }
    }
    *out_actual = received;
    return ZX_OK;
}

static zx_status_t zxio_remote_read_once_at(zxio_remote_t* rio, size_t offset,
                                            uint8_t* buffer, size_t capacity,
                                            size_t* out_actual) {
    size_t actual = 0u;
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileReadAt(rio->control, capacity, offset, &status,
                                      buffer, capacity, &actual);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (actual > capacity) {
        return ZX_ERR_IO;
    }
    *out_actual = actual;
    return ZX_OK;
}

static zx_status_t zxio_remote_read_at(zxio_t* io, size_t offset, void* data,
                                       size_t capacity, size_t* out_actual) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    uint8_t* buffer = static_cast<uint8_t*>(data);
    size_t received = 0;
    while (capacity > 0) {
        size_t chunk = (capacity > ZXIO_REMOTE_CHUNK_SIZE) ? ZXIO_REMOTE_CHUNK_SIZE : capacity;
        size_t actual = 0;
        zx_status_t status = zxio_remote_read_once_at(rio, offset, buffer,
                                                      chunk, &actual);
        if (status != ZX_OK) {
            return status;
        }
        offset += actual;
        received += actual;
        buffer += actual;
        capacity -= actual;
        if (chunk != actual) {
            break;
        }
    }
    *out_actual = received;
    return ZX_OK;
}

static zx_status_t zxio_remote_write_once(zxio_remote_t* rio, const uint8_t* buffer,
                                          size_t capacity, size_t* out_actual) {
    size_t actual = 0u;
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileWrite(rio->control, buffer, capacity, &status,
                                     &actual);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (actual > capacity) {
        return ZX_ERR_IO;
    }
    *out_actual = actual;
    return ZX_OK;
}

static zx_status_t zxio_remote_write(zxio_t* io, const void* data,
                                     size_t capacity, size_t* out_actual) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    const uint8_t* buffer = static_cast<const uint8_t*>(data);
    size_t sent = 0u;
    while (capacity > 0) {
        size_t chunk = (capacity > ZXIO_REMOTE_CHUNK_SIZE) ? ZXIO_REMOTE_CHUNK_SIZE : capacity;
        size_t actual = 0u;
        zx_status_t status = zxio_remote_write_once(rio, buffer, chunk,
                                                    &actual);
        if (status != ZX_OK) {
            return status;
        }
        sent += actual;
        buffer += actual;
        capacity -= actual;
        if (chunk != actual) {
            break;
        }
    }
    *out_actual = sent;
    return ZX_OK;
}

static zx_status_t zxio_remote_write_once_at(zxio_remote_t* rio, size_t offset,
                                             const uint8_t* buffer, size_t capacity,
                                             size_t* out_actual) {
    size_t actual = 0u;
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileWriteAt(rio->control, buffer, capacity, offset,
                                       &status, &actual);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (actual > capacity) {
        return ZX_ERR_IO;
    }
    *out_actual = actual;
    return ZX_OK;
}

static zx_status_t zxio_remote_write_at(zxio_t* io, size_t offset,
                                        const void* data, size_t capacity,
                                        size_t* out_actual) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    const uint8_t* buffer = static_cast<const uint8_t*>(data);
    size_t sent = 0u;
    while (capacity > 0) {
        size_t chunk = (capacity > ZXIO_REMOTE_CHUNK_SIZE) ? ZXIO_REMOTE_CHUNK_SIZE : capacity;
        size_t actual = 0u;
        zx_status_t status = zxio_remote_write_once_at(rio, offset, buffer,
                                                       chunk, &actual);
        if (status != ZX_OK) {
            return status;
        }
        sent += actual;
        buffer += actual;
        offset += actual;
        capacity -= actual;
        if (chunk != actual) {
            break;
        }
    }
    *out_actual = sent;
    return ZX_OK;
}

static zx_status_t zxio_remote_seek(zxio_t* io, size_t offset, zxio_seek_origin_t start, size_t* out_offset) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileSeek(rio->control, offset, start, &status, out_offset);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_truncate(zxio_t* io, size_t length) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileTruncate(rio->control, length, &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_flags_get(zxio_t* io, uint32_t* out_flags) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileGetFlags(rio->control, &status, out_flags);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_flags_set(zxio_t* io, uint32_t flags) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileSetFlags(rio->control, flags, &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_vmo_get(zxio_t* io, uint32_t flags, zx_handle_t* out_vmo, size_t* out_size) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    fuchsia_mem_Buffer buffer{};
    zx_status_t io_status, status;
    io_status = fuchsia_io_FileGetBuffer(rio->control, flags, &status, &buffer);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (buffer.vmo == ZX_HANDLE_INVALID) {
        return ZX_ERR_IO;
    }
    *out_vmo = buffer.vmo;
    *out_size = buffer.size;
    return ZX_OK;
}

static zx_status_t zxio_remote_open_async(zxio_t* io, uint32_t flags, uint32_t mode, const char* path, zx_handle_t request) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    return fuchsia_io_DirectoryOpen(rio->control, flags, mode, path, strlen(path), request);
}

static zx_status_t zxio_remote_unlink(zxio_t* io, const char* path) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryUnlink(rio->control, path, strlen(path), &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_token_get(zxio_t* io, zx_handle_t* out_token) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryGetToken(rio->control, &status, out_token);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_rename(zxio_t* io, const char* src_path, zx_handle_t dst_token, const char* dst_path) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryRename(rio->control, src_path, strlen(src_path), dst_token,
                                           dst_path, strlen(dst_path), &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_link(zxio_t* io, const char* src_path, zx_handle_t dst_token, const char* dst_path) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryLink(rio->control, src_path, strlen(src_path), dst_token,
                                         dst_path, strlen(dst_path), &status);
    return io_status != ZX_OK ? io_status : status;
}

static zx_status_t zxio_remote_readdir(zxio_t* io, void* buffer, size_t capacity, size_t* out_actual) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    size_t actual = 0u;
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryReadDirents(rio->control, capacity, &status,
                                                static_cast<uint8_t*>(buffer),
                                                capacity, &actual);
    if (io_status != ZX_OK) {
        return io_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    if (actual > capacity) {
        return ZX_ERR_IO;
    }
    *out_actual = actual;
    return status;
}

static zx_status_t zxio_remote_rewind(zxio_t* io) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    zx_status_t io_status, status;
    io_status = fuchsia_io_DirectoryRewind(rio->control, &status);
    return io_status != ZX_OK ? io_status : status;
}

// Closes the |zx_handle_t| in |info|, if one exists.
static void zxio_object_close_handle_if_present(const fuchsia_io_NodeInfo* info) {
    switch (info->tag) {
    case fuchsia_io_NodeInfoTag_file:
        if (info->file.event != ZX_HANDLE_INVALID) {
            zx_handle_close(info->file.event);
        }
        break;
    case fuchsia_io_NodeInfoTag_pipe:
        if (info->pipe.socket != ZX_HANDLE_INVALID) {
            zx_handle_close(info->pipe.socket);
        }
        break;
    case fuchsia_io_NodeInfoTag_vmofile:
        if (info->vmofile.vmo != ZX_HANDLE_INVALID) {
            zx_handle_close(info->vmofile.vmo);
        }
        break;
    case fuchsia_io_NodeInfoTag_device:
        if (info->device.event != ZX_HANDLE_INVALID) {
            zx_handle_close(info->device.event);
        }
        break;
    case fuchsia_io_NodeInfoTag_tty:
        if (info->tty.event != ZX_HANDLE_INVALID) {
            zx_handle_close(info->tty.event);
        }
        break;
    }
}

static zx_status_t zxio_remote_isatty(zxio_t* io, bool* tty) {
    zxio_remote_t* rio = reinterpret_cast<zxio_remote_t*>(io);
    fuchsia_io_NodeInfo info;
    zx_status_t io_status = fuchsia_io_NodeDescribe(rio->control, &info);
    if (io_status == ZX_OK) {
        if (info.tag == fuchsia_io_NodeInfoTag_tty) {
            *tty = true;
        } else {
            *tty = false;
        }
        zxio_object_close_handle_if_present(&info);
    }

    return io_status;
}

static constexpr zxio_ops_t zxio_remote_ops = []() {
    zxio_ops_t ops = zxio_default_ops;
    ops.close = zxio_remote_close;
    ops.release = zxio_remote_release;
    ops.clone = zxio_remote_clone;
    ops.sync = zxio_remote_sync;
    ops.attr_get = zxio_remote_attr_get;
    ops.attr_set = zxio_remote_attr_set;
    ops.read = zxio_remote_read;
    ops.read_at = zxio_remote_read_at;
    ops.write = zxio_remote_write;
    ops.write_at = zxio_remote_write_at;
    ops.seek = zxio_remote_seek;
    ops.truncate = zxio_remote_truncate;
    ops.flags_get = zxio_remote_flags_get;
    ops.flags_set = zxio_remote_flags_set;
    ops.vmo_get = zxio_remote_vmo_get;
    ops.open_async = zxio_remote_open_async;
    ops.unlink = zxio_remote_unlink;
    ops.token_get = zxio_remote_token_get;
    ops.rename = zxio_remote_rename;
    ops.link = zxio_remote_link;
    ops.readdir = zxio_remote_readdir;
    ops.rewind = zxio_remote_rewind;
    ops.isatty = zxio_remote_isatty;
    return ops;
}();

zx_status_t zxio_remote_init(zxio_storage_t* storage, zx_handle_t control,
                             zx_handle_t event) {
    zxio_remote_t* remote = reinterpret_cast<zxio_remote_t*>(storage);
    zxio_init(&remote->io, &zxio_remote_ops);
    remote->control = control;
    remote->event = event;
    return ZX_OK;
}

static zx_status_t zxio_dir_read(zxio_t* io, void* data, size_t capacity,
                                    size_t* out_actual) {
    if (capacity == 0) {
        // zero-sized reads to directories should always succeed
        *out_actual = 0;
        return ZX_OK;
    }
    return ZX_ERR_WRONG_TYPE;
}

static zx_status_t zxio_dir_read_at(zxio_t* io, size_t offset, void* data,
                                       size_t capacity, size_t* out_actual) {
    if (capacity == 0) {
        // zero-sized reads to directories should always succeed
        *out_actual = 0;
        return ZX_OK;
    }
    return ZX_ERR_WRONG_TYPE;
}

static constexpr zxio_ops_t zxio_dir_ops = []() {
    zxio_ops_t ops = zxio_default_ops;
    ops.close = zxio_remote_close;
    ops.release = zxio_remote_release;
    ops.clone = zxio_remote_clone;
    ops.sync = zxio_remote_sync;
    ops.attr_get = zxio_remote_attr_get;
    ops.attr_set = zxio_remote_attr_set;
    // use specialized read functions that succeed for zero-sized reads.
    ops.read = zxio_dir_read;
    ops.read_at = zxio_dir_read_at;
    ops.flags_get = zxio_remote_flags_get;
    ops.flags_set = zxio_remote_flags_set;
    ops.open_async = zxio_remote_open_async;
    ops.unlink = zxio_remote_unlink;
    ops.token_get = zxio_remote_token_get;
    ops.rename = zxio_remote_rename;
    ops.link = zxio_remote_link;
    ops.readdir = zxio_remote_readdir;
    ops.rewind = zxio_remote_rewind;
    return ops;
}();

zx_status_t zxio_dir_init(zxio_storage_t* storage, zx_handle_t control) {
    zxio_remote_t* remote = reinterpret_cast<zxio_remote_t*>(storage);
    zxio_init(&remote->io, &zxio_dir_ops);
    remote->control = control;
    remote->event = ZX_HANDLE_INVALID;
    return ZX_OK;
}

static constexpr zxio_ops_t zxio_file_ops = []() {
    zxio_ops_t ops = zxio_default_ops;
    ops.close = zxio_remote_close;
    ops.release = zxio_remote_release;
    ops.clone = zxio_remote_clone;
    ops.sync = zxio_remote_sync;
    ops.attr_get = zxio_remote_attr_get;
    ops.attr_set = zxio_remote_attr_set;
    ops.read = zxio_remote_read;
    ops.read_at = zxio_remote_read_at;
    ops.write = zxio_remote_write;
    ops.write_at = zxio_remote_write_at;
    ops.seek = zxio_remote_seek;
    ops.truncate = zxio_remote_truncate;
    ops.flags_get = zxio_remote_flags_get;
    ops.flags_set = zxio_remote_flags_set;
    return ops;
}();

zx_status_t zxio_file_init(zxio_storage_t* storage, zx_handle_t control,
                           zx_handle_t event) {
    zxio_remote_t* remote = reinterpret_cast<zxio_remote_t*>(storage);
    zxio_init(&remote->io, &zxio_file_ops);
    remote->control = control;
    remote->event = event;
    return ZX_OK;
}