// Copyright 2016 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 "zircon_platform_connection.h"

#include "platform_connection.h"
#include "zircon_platform_event.h"
#include <fuchsia/gpu/magma/cpp/fidl.h>
#include <lib/fidl/cpp/binding.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async/task.h>
#include <lib/async/time.h>
#include <lib/async/wait.h>
#include <lib/zx/channel.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include <zircon/types.h>

namespace magma {

template <typename T>
T* OpCast(uint8_t* bytes, uint32_t num_bytes, zx_handle_t* handles, uint32_t kNumHandles)
{
    if (num_bytes != sizeof(T))
        return DRETP(nullptr, "wrong number of bytes in message, expected %zu, got %u", sizeof(T),
                     num_bytes);
    if (kNumHandles != T::kNumHandles)
        return DRETP(nullptr, "wrong number of handles in message");
    return reinterpret_cast<T*>(bytes);
}

template <>
ExecuteImmediateCommandsOp* OpCast<ExecuteImmediateCommandsOp>(uint8_t* bytes, uint32_t num_bytes,
                                                               zx_handle_t* handles,
                                                               uint32_t kNumHandles)
{
    if (num_bytes < sizeof(ExecuteImmediateCommandsOp))
        return DRETP(nullptr, "too few bytes for executing immediate commands %u", num_bytes);

    auto execute_immediate_commands_op = reinterpret_cast<ExecuteImmediateCommandsOp*>(bytes);
    uint32_t expected_size =
        ExecuteImmediateCommandsOp::size(execute_immediate_commands_op->semaphore_count,
                                         execute_immediate_commands_op->commands_size);
    if (num_bytes != expected_size)
        return DRETP(nullptr, "wrong number of bytes in message, expected %u, got %u",
                     expected_size, num_bytes);
    if (kNumHandles != ExecuteImmediateCommandsOp::kNumHandles)
        return DRETP(nullptr, "wrong number of handles in message");
    return reinterpret_cast<ExecuteImmediateCommandsOp*>(bytes);
}

class ZirconPlatformConnection : public PlatformConnection, public fuchsia::gpu::magma::Primary {
public:
    struct AsyncWait : public async_wait {
        AsyncWait(ZirconPlatformConnection* connection, zx_handle_t object, zx_signals_t trigger)
        {
            this->state = ASYNC_STATE_INIT;
            this->handler = AsyncWaitHandlerStatic;
            this->object = object;
            this->trigger = trigger;
            this->connection = connection;
        }
        ZirconPlatformConnection* connection;
    };

    struct AsyncTask : public async_task {
        AsyncTask(ZirconPlatformConnection* connection, msd_notification_t* notification)
        {
            this->state = ASYNC_STATE_INIT;
            this->handler = AsyncTaskHandlerStatic;
            this->deadline = async_now(connection->async_loop()->dispatcher());
            this->connection = connection;
            // Copy the notification struct
            this->notification = *notification;
        }

        ZirconPlatformConnection* connection;
        msd_notification_t notification;
    };

    ZirconPlatformConnection(std::unique_ptr<Delegate> delegate, zx::channel server_endpoint,
                             zx::channel client_endpoint, zx::channel server_notification_endpoint,
                             zx::channel client_notification_endpoint,
                             std::shared_ptr<magma::PlatformEvent> shutdown_event)
        : magma::PlatformConnection(shutdown_event), delegate_(std::move(delegate)),
#if !MAGMA_FIDL
          server_endpoint_(std::move(server_endpoint)),
#endif
          client_endpoint_(std::move(client_endpoint)),
          server_notification_endpoint_(std::move(server_notification_endpoint)),
          client_notification_endpoint_(std::move(client_notification_endpoint)),
          async_loop_(&kAsyncLoopConfigNoAttachToThread),
#if !MAGMA_FIDL
          async_wait_channel_(this, server_endpoint_.get(),
                              ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED),
#endif
          async_wait_shutdown_(
              this, static_cast<magma::ZirconPlatformEvent*>(shutdown_event.get())->zx_handle(),
              ZX_EVENT_SIGNALED)
#if MAGMA_FIDL
          ,
          binding_(this, std::move(server_endpoint), async_loop_.dispatcher())
#endif
    {
#if MAGMA_FIDL
        binding_.set_error_handler([this](zx_status_t status) { async_loop()->Quit(); });
#endif
        delegate_->SetNotificationCallback(NotificationCallbackStatic, this);
    }

    ~ZirconPlatformConnection() { delegate_->SetNotificationCallback(nullptr, 0); }

    bool HandleRequest() override
    {
        zx_status_t status = async_loop_.Run(zx::time::infinite(), true /* once */);
        if (status != ZX_OK)
            return false;
        return true;
    }

#if !MAGMA_FIDL
    bool BeginChannelWait()
    {
        zx_status_t status = async_begin_wait(async_loop()->dispatcher(), &async_wait_channel_);
        if (status != ZX_OK)
            return DRETF(false, "Couldn't begin wait on channel: %s", zx_status_get_string(status));
        return true;
    }
#endif

    bool BeginShutdownWait()
    {
        zx_status_t status = async_begin_wait(async_loop()->dispatcher(), &async_wait_shutdown_);
        if (status != ZX_OK)
            return DRETF(false, "Couldn't begin wait on shutdown: %s",
                         zx_status_get_string(status));
        return true;
    }

#if !MAGMA_FIDL
    bool ReadChannel()
    {
        constexpr uint32_t kNumBytes = fuchsia::gpu::magma::kReceiveBufferSize;
        constexpr uint32_t kNumHandles = 1;

        uint32_t actual_bytes;
        uint32_t actual_handles;

        uint8_t bytes[kNumBytes];
        zx_handle_t handles[kNumHandles];

        zx_status_t status = server_endpoint_.read(0, bytes, kNumBytes, &actual_bytes, handles,
                                                   kNumHandles, &actual_handles);
        if (status != ZX_OK)
            return DRETF(false, "failed to read from channel");

        if (actual_bytes < sizeof(OpCode))
            return DRETF(false, "malformed message");

        OpCode* opcode = reinterpret_cast<OpCode*>(bytes);
        bool success = false;
        switch (*opcode) {
            case OpCode::ImportBuffer:
                success = ImportBuffer(
                    OpCast<ImportBufferOp>(bytes, actual_bytes, handles, actual_handles), handles);
                break;
            case OpCode::ReleaseBuffer:
                success = ReleaseBuffer(
                    OpCast<ReleaseBufferOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::ImportObject:
                success = ImportObject(
                    OpCast<ImportObjectOp>(bytes, actual_bytes, handles, actual_handles), handles);
                break;
            case OpCode::ReleaseObject:
                success = ReleaseObject(
                    OpCast<ReleaseObjectOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::CreateContext:
                success = CreateContext(
                    OpCast<CreateContextOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::DestroyContext:
                success = DestroyContext(
                    OpCast<DestroyContextOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::ExecuteCommandBuffer:
                success = ExecuteCommandBuffer(
                    OpCast<ExecuteCommandBufferOp>(bytes, actual_bytes, handles, actual_handles),
                    handles);
                break;
            case OpCode::ExecuteImmediateCommands:
                success = ExecuteImmediateCommands(OpCast<ExecuteImmediateCommandsOp>(
                    bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::GetError:
                success =
                    GetError(OpCast<GetErrorOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::MapBufferGpu:
                success = MapBufferGpu(
                    OpCast<MapBufferGpuOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::UnmapBufferGpu:
                success = UnmapBufferGpu(
                    OpCast<UnmapBufferGpuOp>(bytes, actual_bytes, handles, actual_handles));
                break;
            case OpCode::CommitBuffer:
                success = CommitBuffer(
                    OpCast<CommitBufferOp>(bytes, actual_bytes, handles, actual_handles));
                break;
        }

        if (!success)
            return DRETF(false, "failed to interpret message");

        if (error_)
            return DRETF(false, "PlatformConnection encountered fatal error");

        return true;
    }
#endif

    uint32_t GetClientEndpoint() override
    {
        DASSERT(client_endpoint_);
        return client_endpoint_.release();
    }

    uint32_t GetClientNotificationEndpoint() override
    {
        DASSERT(client_notification_endpoint_);
        return client_notification_endpoint_.release();
    }

    async::Loop* async_loop() { return &async_loop_; }

private:
    static void AsyncWaitHandlerStatic(async_dispatcher_t* dispatcher, async_wait_t* async_wait,
                                       zx_status_t status, const zx_packet_signal_t* signal)
    {
        auto wait = static_cast<AsyncWait*>(async_wait);
        wait->connection->AsyncWaitHandler(dispatcher, wait, status, signal);
    }

    void AsyncWaitHandler(async_dispatcher_t* dispatcher, AsyncWait* wait, zx_status_t status,
                          const zx_packet_signal_t* signal)
    {
        if (status != ZX_OK)
            return;

        bool quit = false;
        if (wait == &async_wait_shutdown_) {
            DASSERT(signal->observed == ZX_EVENT_SIGNALED);
            quit = true;
            DLOG("got shutdown event");
        }
#if !MAGMA_FIDL
        else if (wait == &async_wait_channel_ && signal->observed & ZX_CHANNEL_PEER_CLOSED) {
            quit = true;
        } else if (wait == &async_wait_channel_ && signal->observed & ZX_CHANNEL_READABLE) {
            if (!ReadChannel() || !BeginChannelWait()) {
                quit = true;
            }
        }
#endif
        else {
            DASSERT(false);
        }

        if (quit) {
            async_loop()->Quit();
        }
    }

    // Could occur on an arbitrary thread (see |msd_connection_set_notification_callback|).
    // MSD must ensure we aren't in the process of destroying our connection.
    static void NotificationCallbackStatic(void* token, msd_notification_t* notification)
    {
        auto connection = static_cast<ZirconPlatformConnection*>(token);
        zx_status_t status = async_post_task(connection->async_loop()->dispatcher(),
                                             new AsyncTask(connection, notification));
        if (status != ZX_OK)
            DLOG("async_post_task failed, status %s", zx_status_get_string(status));
    }

    static void AsyncTaskHandlerStatic(async_dispatcher_t* dispatcher, async_task_t* async_task,
                                       zx_status_t status)
    {
        auto task = static_cast<AsyncTask*>(async_task);
        task->connection->AsyncTaskHandler(dispatcher, task, status);
        delete task;
    }

    bool AsyncTaskHandler(async_dispatcher_t* dispatcher, AsyncTask* task, zx_status_t status)
    {
        switch (static_cast<MSD_CONNECTION_NOTIFICATION_TYPE>(task->notification.type)) {
            case MSD_CONNECTION_NOTIFICATION_CHANNEL_SEND: {
                zx_status_t status = zx_channel_write(
                    server_notification_endpoint_.get(), 0, task->notification.u.channel_send.data,
                    task->notification.u.channel_send.size, nullptr, 0);
                if (status != ZX_OK)
                    return DRETF(false, "Failed writing to channel: %s", zx_status_get_string(status));
                return true;
            }
            case MSD_CONNECTION_NOTIFICATION_CONTEXT_KILLED:
                // Kill the connection.
                ShutdownEvent()->Signal();
                return true;
        }
        return DRETF(false, "Unhandled notification type: %d", task->notification.type);
    }

    bool ImportBuffer(ImportBufferOp* op, zx_handle_t* handle)
    {
        DLOG("ZirconPlatformConnection: ImportBuffer");
        if (!op)
            return DRETF(false, "malformed message");
        uint64_t buffer_id;
        if (!delegate_->ImportBuffer(*handle, &buffer_id))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void ImportBufferFIDL(zx::vmo vmo) override
    {
        DLOG("ZirconPlatformConnection - ImportBufferFIDL");
        uint64_t buffer_id;
        if (!delegate_->ImportBuffer(vmo.release(), &buffer_id)) {
            SetError(MAGMA_STATUS_INVALID_ARGS);
        }
    }

    bool ReleaseBuffer(ReleaseBufferOp* op)
    {
        DLOG("ZirconPlatformConnection: ReleaseBuffer");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->ReleaseBuffer(op->buffer_id))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void ReleaseBufferFIDL(uint64_t buffer_id) override
    {
        DLOG("ZirconPlatformConnection: ReleaseBufferFIDL");
        if (!delegate_->ReleaseBuffer(buffer_id))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    bool ImportObject(ImportObjectOp* op, zx_handle_t* handle)
    {
        DLOG("ZirconPlatformConnection: ImportObject");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->ImportObject(*handle, static_cast<PlatformObject::Type>(op->object_type)))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void ImportObjectFIDL(zx::handle handle, uint32_t object_type) override
    {
        DLOG("ZirconPlatformConnection: ImportObjectFIDL");
        if (!delegate_->ImportObject(handle.release(),
                                     static_cast<PlatformObject::Type>(object_type)))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    bool ReleaseObject(ReleaseObjectOp* op)
    {
        DLOG("ZirconPlatformConnection: ReleaseObject");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->ReleaseObject(op->object_id,
                                      static_cast<PlatformObject::Type>(op->object_type)))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void ReleaseObjectFIDL(uint64_t object_id, uint32_t object_type) override
    {
        DLOG("ZirconPlatformConnection: ReleaseObjectFIDL");
        if (!delegate_->ReleaseObject(object_id, static_cast<PlatformObject::Type>(object_type)))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    bool CreateContext(CreateContextOp* op)
    {
        DLOG("ZirconPlatformConnection: CreateContext");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->CreateContext(op->context_id))
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
        return true;
    }

    void CreateContextFIDL(uint32_t context_id) override
    {
        DLOG("ZirconPlatformConnection: CreateContextFIDL");
        if (!delegate_->CreateContext(context_id))
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
    }

    bool DestroyContext(DestroyContextOp* op)
    {
        DLOG("ZirconPlatformConnection: DestroyContext");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->DestroyContext(op->context_id))
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
        return true;
    }

    void DestroyContextFIDL(uint32_t context_id) override
    {
        DLOG("ZirconPlatformConnection: DestroyContextFIDL");
        if (!delegate_->DestroyContext(context_id))
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
    }

    bool ExecuteCommandBuffer(ExecuteCommandBufferOp* op, zx_handle_t* handle)
    {
        DLOG("ZirconPlatformConnection: ExecuteCommandBuffer");
        if (!op)
            return DRETF(false, "malformed message");
        magma::Status status = delegate_->ExecuteCommandBuffer(*handle, op->context_id);
        if (status.get() == MAGMA_STATUS_CONTEXT_KILLED)
            ShutdownEvent()->Signal();
        if (!status)
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
        return true;
    }

    void ExecuteCommandBufferFIDL(zx::handle command_buffer, uint32_t context_id) override
    {
        DLOG("ZirconPlatformConnection: ExecuteCommandBufferFIDL");
        magma::Status status =
            delegate_->ExecuteCommandBuffer(command_buffer.release(), context_id);
        if (status.get() == MAGMA_STATUS_CONTEXT_KILLED)
            ShutdownEvent()->Signal();
        if (!status)
            SetError(MAGMA_STATUS_INTERNAL_ERROR);
    }

    bool ExecuteImmediateCommands(ExecuteImmediateCommandsOp* op)
    {
        DLOG("ZirconPlatformConnection: ExecuteImmediateCommands");
        if (!op)
            return DRETF(false, "malformed message");

        magma::Status status = delegate_->ExecuteImmediateCommands(
            op->context_id, op->commands_size, op->command_data(), op->semaphore_count,
            op->semaphores);
        if (!status)
            SetError(status.get());
        return true;
    }

    void ExecuteImmediateCommandsFIDL(uint32_t context_id, ::std::vector<uint8_t> command_data_vec,
                                      ::std::vector<uint64_t> semaphore_vec) override
    {
        DLOG("ZirconPlatformConnection: ExecuteImmediateCommandsFIDL");
        magma::Status status = delegate_->ExecuteImmediateCommands(
            context_id, command_data_vec.size(), command_data_vec.data(), semaphore_vec.size(),
            semaphore_vec.data());
        if (!status)
            SetError(status.get());
    }

    bool GetError(GetErrorOp* op)
    {
        DLOG("ZirconPlatformConnection: GetError");
        if (!op)
            return DRETF(false, "malformed message");
        magma_status_t result = error_;
        error_ = 0;
        if (!WriteError(result))
            return false;
        return true;
    }

    void GetErrorFIDL(fuchsia::gpu::magma::Primary::GetErrorFIDLCallback error_callback) override
    {
        magma_status_t result = error_;
        error_ = 0;
        error_callback(result);
    }

    bool MapBufferGpu(MapBufferGpuOp* op)
    {
        DLOG("ZirconPlatformConnection: MapBufferGpu");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->MapBufferGpu(op->buffer_id, op->gpu_va, op->page_offset, op->page_count,
                                     op->flags))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void MapBufferGpuFIDL(uint64_t buffer_id, uint64_t gpu_va, uint64_t page_offset,
                          uint64_t page_count, uint64_t flags) override
    {
        DLOG("ZirconPlatformConnection: MapBufferGpuFIDL");
        if (!delegate_->MapBufferGpu(buffer_id, gpu_va, page_offset, page_count, flags))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    bool UnmapBufferGpu(UnmapBufferGpuOp* op)
    {
        DLOG("ZirconPlatformConnection: UnmapBufferGpu");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->UnmapBufferGpu(op->buffer_id, op->gpu_va))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void UnmapBufferGpuFIDL(uint64_t buffer_id, uint64_t gpu_va) override
    {
        DLOG("ZirconPlatformConnection: UnmapBufferGpuFIDL");
        if (!delegate_->UnmapBufferGpu(buffer_id, gpu_va))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    bool CommitBuffer(CommitBufferOp* op)
    {
        DLOG("ZirconPlatformConnection: CommitBuffer");
        if (!op)
            return DRETF(false, "malformed message");
        if (!delegate_->CommitBuffer(op->buffer_id, op->page_offset, op->page_count))
            SetError(MAGMA_STATUS_INVALID_ARGS);
        return true;
    }

    void CommitBufferFIDL(uint64_t buffer_id, uint64_t page_offset, uint64_t page_count) override
    {
        DLOG("ZirconPlatformConnection: CommitBufferFIDL");
        if (!delegate_->CommitBuffer(buffer_id, page_offset, page_count))
            SetError(MAGMA_STATUS_INVALID_ARGS);
    }

    void SetError(magma_status_t error)
    {
        if (!error_)
            error_ = DRET_MSG(error, "ZirconPlatformConnection encountered dispatcher error");
    }

    bool WriteError(magma_status_t error)
    {
        DLOG("Writing error %d to channel", error);
        zx_status_t status = server_endpoint_.write(0, &error, sizeof(error), nullptr, 0);
        return DRETF(status == ZX_OK, "failed to write to channel");
    }

    std::unique_ptr<Delegate> delegate_;
    zx::channel server_endpoint_;
    zx::channel client_endpoint_;
    magma_status_t error_{};
    zx::channel server_notification_endpoint_;
    zx::channel client_notification_endpoint_;
    async::Loop async_loop_;
#if !MAGMA_FIDL
    AsyncWait async_wait_channel_;
#endif
    AsyncWait async_wait_shutdown_;

#if MAGMA_FIDL
    fidl::Binding<fuchsia::gpu::magma::Primary> binding_;
#endif
};

std::shared_ptr<PlatformConnection>
PlatformConnection::Create(std::unique_ptr<PlatformConnection::Delegate> delegate)
{
    if (!delegate)
        return DRETP(nullptr, "attempting to create PlatformConnection with null delegate");

    zx::channel server_endpoint;
    zx::channel client_endpoint;
    zx_status_t status = zx::channel::create(0, &server_endpoint, &client_endpoint);
    if (status != ZX_OK)
        return DRETP(nullptr, "zx::channel::create failed");

    zx::channel server_notification_endpoint;
    zx::channel client_notification_endpoint;
    status = zx::channel::create(0, &server_notification_endpoint, &client_notification_endpoint);
    if (status != ZX_OK)
        return DRETP(nullptr, "zx::channel::create failed");

    auto shutdown_event = magma::PlatformEvent::Create();
    if (!shutdown_event)
        return DRETP(nullptr, "Failed to create shutdown event");

    auto connection = std::make_shared<ZirconPlatformConnection>(
        std::move(delegate), std::move(server_endpoint), std::move(client_endpoint),
        std::move(server_notification_endpoint), std::move(client_notification_endpoint),
        std::shared_ptr<magma::PlatformEvent>(std::move(shutdown_event)));

#if !MAGMA_FIDL
    if (!connection->BeginChannelWait())
        return DRETP(nullptr, "Failed to begin channel wait");
#endif

    if (!connection->BeginShutdownWait())
        return DRETP(nullptr, "Failed to begin shutdown wait");

    return connection;
}

} // namespace magma