/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "QemuPipeStream.h"

#include <cutils/log.h>
#include <errno.h>
#include <fuchsia/hardware/goldfish/pipe/c/fidl.h>
#include <lib/fdio/fdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <zircon/process.h>

#include <utility>

QemuPipeStream::QemuPipeStream(size_t bufSize) :
    IOStream(bufSize),
    m_sock(-1),
    m_bufsize(bufSize),
    m_buf(nullptr)
{
}

QemuPipeStream::QemuPipeStream(QEMU_PIPE_HANDLE sock, size_t bufSize) :
    IOStream(bufSize),
    m_sock(sock),
    m_bufsize(bufSize),
    m_buf(nullptr)
{
}

QemuPipeStream::~QemuPipeStream()
{
    if (m_channel.is_valid()) {
        flush();
    }
    if (m_buf) {
        zx_status_t status = zx_vmar_unmap(zx_vmar_root_self(),
                                           reinterpret_cast<zx_vaddr_t>(m_buf),
                                           m_bufsize);
        if (status != ZX_OK) {
            ALOGE("zx_vmar_unmap failed: %d\n", status);
            abort();
        }
    }
}

int QemuPipeStream::connect(void)
{
    int fd = TEMP_FAILURE_RETRY(open(QEMU_PIPE_PATH, O_RDWR));
    if (fd < 0) {
        ALOGE("%s: failed to open " QEMU_PIPE_PATH ": %s",
              __FUNCTION__, strerror(errno));
        return -1;
    }

    zx::channel channel;
    zx_status_t status = fdio_get_service_handle(
        fd, channel.reset_and_get_address());
    if (status != ZX_OK) {
        ALOGE("%s: failed to get service handle for " QEMU_PIPE_PATH ": %d",
              __FUNCTION__, status);
        close(fd);
        return -1;
    }

    zx::event event;
    status = zx::event::create(0, &event);
    if (status != ZX_OK) {
        ALOGE("%s: failed to create event: %d", __FUNCTION__, status);
        return -1;
    }
    zx::event event_copy;
    status = event.duplicate(ZX_RIGHT_SAME_RIGHTS, &event_copy);
    if (status != ZX_OK) {
        ALOGE("%s: failed to duplicate event: %d", __FUNCTION__, status);
        return -1;
    }

    status = fuchsia_hardware_goldfish_pipe_DeviceSetEvent(
        channel.get(), event_copy.release());
    if (status != ZX_OK) {
        ALOGE("%s: failed to set event: %d:%d", __FUNCTION__, status);
        return -1;
    }

    zx_status_t status2 = ZX_OK;
    zx::vmo vmo;
    status = fuchsia_hardware_goldfish_pipe_DeviceGetBuffer(
        channel.get(), &status2, vmo.reset_and_get_address());
    if (status != ZX_OK || status2 != ZX_OK) {
        ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
        return -1;
    }

    size_t len = strlen("pipe:opengles");
    status = vmo.write("pipe:opengles", 0, len + 1);
    if (status != ZX_OK) {
        ALOGE("%s: failed write pipe name", __FUNCTION__);
        return -1;
    }

    uint64_t actual;
    status = fuchsia_hardware_goldfish_pipe_DeviceWrite(
        channel.get(), len + 1, 0, &status2, &actual);
    if (status != ZX_OK || status2 != ZX_OK) {
        ALOGD("%s: connecting to pipe service failed: %d:%d", __FUNCTION__,
              status, status2);
        return -1;
    }

    m_channel = std::move(channel);
    m_event = std::move(event);
    m_vmo = std::move(vmo);
    return 0;
}

void *QemuPipeStream::allocBuffer(size_t minSize)
{
    zx_status_t status;
    if (m_buf) {
        if (minSize <= m_bufsize) {
            return m_buf;
        }
        status = zx_vmar_unmap(zx_vmar_root_self(),
                               reinterpret_cast<zx_vaddr_t>(m_buf),
                               m_bufsize);
        if (status != ZX_OK) {
          ALOGE("zx_vmar_unmap failed: %d\n", status);
          abort();
        }
        m_buf = nullptr;
    }

    size_t allocSize = m_bufsize < minSize ? minSize : m_bufsize;

    zx_status_t status2 = ZX_OK;
    status = fuchsia_hardware_goldfish_pipe_DeviceSetBufferSize(
        m_channel.get(), allocSize, &status2);
    if (status != ZX_OK || status2 != ZX_OK) {
        ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
        return nullptr;
    }

    zx::vmo vmo;
    status = fuchsia_hardware_goldfish_pipe_DeviceGetBuffer(
        m_channel.get(), &status2, vmo.reset_and_get_address());
    if (status != ZX_OK || status2 != ZX_OK) {
        ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__, status, status2);
        return nullptr;
    }

    zx_vaddr_t mapped_addr;
    status = zx_vmar_map(zx_vmar_root_self(),
                         ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
                         0, vmo.get(), 0, allocSize, &mapped_addr);
    if (status != ZX_OK) {
        ALOGE("%s: failed to map buffer: %d:%d", __FUNCTION__, status);
        return nullptr;
    }

    m_buf = reinterpret_cast<unsigned char*>(mapped_addr);
    m_bufsize = allocSize;
    m_vmo = std::move(vmo);
    return m_buf;
}

int QemuPipeStream::commitBuffer(size_t size)
{
    if (size == 0) return 0;

    size_t remaining = size;
    while (remaining) {
        zx_status_t status2 = ZX_OK;
        uint64_t actual = 0;
        zx_status_t status = fuchsia_hardware_goldfish_pipe_DeviceWrite(
            m_channel.get(), remaining, size - remaining, &status2, &actual);
        if (status != ZX_OK) {
            ALOGD("%s: Failed writing to pipe: %d", __FUNCTION__, status);
            return -1;
        }
        if (actual) {
            remaining -= actual;
            continue;
        }
        if (status2 != ZX_ERR_SHOULD_WAIT) {
            ALOGD("%s: Error writing to pipe: %d", __FUNCTION__, status2);
            return -1;
        }
        zx_signals_t observed = ZX_SIGNAL_NONE;
        status = m_event.wait_one(
            fuchsia_hardware_goldfish_pipe_SIGNAL_WRITABLE |
            fuchsia_hardware_goldfish_pipe_SIGNAL_HANGUP,
            zx::time::infinite(), &observed);
        if (status != ZX_OK) {
            ALOGD("%s: wait_one failed: %d", __FUNCTION__, status);
            return -1;
        }
        if (observed & fuchsia_hardware_goldfish_pipe_SIGNAL_HANGUP) {
            ALOGD("%s: Remote end hungup", __FUNCTION__);
            return -1;
        }
    }

    return 0;
}

int QemuPipeStream::writeFully(const void *buf, size_t len)
{
    ALOGE("%s: unsupported", __FUNCTION__);
    abort();
    return -1;
}

QEMU_PIPE_HANDLE QemuPipeStream::getSocket() const {
    return m_sock;
}

const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
{
    if (!m_channel.is_valid()) return nullptr;

    if (!buf) {
        if (len > 0) {
            ALOGE("QemuPipeStream::readFully failed, buf=NULL, len %zu, lethal"
                    " error, exiting.", len);
            abort();
        }
        return nullptr;
    }

    size_t remaining = len;
    while (remaining) {
        size_t readSize = m_bufsize < remaining ? m_bufsize : remaining;
        zx_status_t status2 = ZX_OK;
        uint64_t actual = 0;
        zx_status_t status = fuchsia_hardware_goldfish_pipe_DeviceRead(
            m_channel.get(), readSize, 0, &status2, &actual);
        if (status != ZX_OK) {
            ALOGD("%s: Failed reading from pipe: %d", __FUNCTION__, status);
            return nullptr;
        }
        if (actual) {
            m_vmo.read(static_cast<char *>(buf) + (len - remaining), 0, actual);
            remaining -= actual;
            continue;
        }
        if (status2 != ZX_ERR_SHOULD_WAIT) {
            ALOGD("%s: Error reading from pipe: %d", __FUNCTION__, status2);
            return nullptr;
        }
        zx_signals_t observed = ZX_SIGNAL_NONE;
        status = m_event.wait_one(
            fuchsia_hardware_goldfish_pipe_SIGNAL_READABLE |
            fuchsia_hardware_goldfish_pipe_SIGNAL_HANGUP,
            zx::time::infinite(), &observed);
        if (status != ZX_OK) {
            ALOGD("%s: wait_one failed: %d", __FUNCTION__, status);
            return nullptr;
        }
        if (observed & fuchsia_hardware_goldfish_pipe_SIGNAL_HANGUP) {
            ALOGD("%s: Remote end hungup", __FUNCTION__);
            return nullptr;
        }
    }

    return static_cast<const unsigned char *>(buf);
}

const unsigned char *QemuPipeStream::read(void *buf, size_t *inout_len)
{
    ALOGE("%s: unsupported", __FUNCTION__);
    abort();
    return nullptr;
}

int QemuPipeStream::recv(void *buf, size_t len)
{
    ALOGE("%s: unsupported", __FUNCTION__);
    abort();
    return -1;
}