// SPDX-License-Identifier: MPL-2.0
// Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)

#include <gpu.h>
#include <os.h>
#include <kernel/types/KProcess.h>
#include <services/nvdrv/INvDrvServices.h>
#include <gpu/format.h>
#include "IHOSBinderDriver.h"
#include "display.h"

namespace skyline::service::hosbinder {
    IHOSBinderDriver::IHOSBinderDriver(const DeviceState &state, ServiceManager &manager) : BaseService(state, manager, Service::hosbinder_IHOSBinderDriver, "hosbinder_IHOSBinderDriver", {
        {0x0, SFUNC(IHOSBinderDriver::TransactParcel)},
        {0x1, SFUNC(IHOSBinderDriver::AdjustRefcount)},
        {0x2, SFUNC(IHOSBinderDriver::GetNativeHandle)},
        {0x3, SFUNC(IHOSBinderDriver::TransactParcel)}
    }) {}

    void IHOSBinderDriver::RequestBuffer(Parcel &in, Parcel &out) {
        u32 slot = *reinterpret_cast<u32 *>(in.data.data());
        out.WriteData<u32>(1);
        out.WriteData<u32>(sizeof(GbpBuffer));
        out.WriteData<u32>(0);
        out.WriteData(queue.at(slot)->gbpBuffer);
        state.logger->Debug("RequestBuffer: Slot: {}", slot, sizeof(GbpBuffer));
    }

    void IHOSBinderDriver::DequeueBuffer(Parcel &in, Parcel &out) {
        struct Data {
            u32 format;
            u32 width;
            u32 height;
            u32 timestamps;
            u32 usage;
        } *data = reinterpret_cast<Data *>(in.data.data());

        i64 slot{-1};
        while (slot == -1) {
            for (auto &buffer : queue) {
                if (buffer.second->status == BufferStatus::Free && buffer.second->gbpBuffer.width == data->width && buffer.second->gbpBuffer.height == data->height && buffer.second->gbpBuffer.usage == data->usage) {
                    slot = buffer.first;
                    buffer.second->status = BufferStatus::Dequeued;
                    break;
                }
            }
            asm("yield");
        }

        struct {
            u32 slot;
            u32 _unk_[13];
        } output{
            .slot = static_cast<u32>(slot)
        };
        out.WriteData(output);

        state.logger->Debug("DequeueBuffer: Width: {}, Height: {}, Format: {}, Usage: {}, Timestamps: {}, Slot: {}", data->width, data->height, data->format, data->usage, data->timestamps, slot);
    }

    void IHOSBinderDriver::QueueBuffer(Parcel &in, Parcel &out) {
        struct Data {
            u32 slot;
            u64 timestamp;
            u32 autoTimestamp;
            ARect crop;
            u32 scalingMode;
            u32 transform;
            u32 stickyTransform;
            u64 _unk0_;
            u32 swapInterval;
            Fence fence[4];
        } *data = reinterpret_cast<Data *>(in.data.data());

        auto buffer = queue.at(data->slot);
        buffer->status = BufferStatus::Queued;

        auto slot = data->slot;
        auto bufferEvent = state.gpu->bufferEvent;
        buffer->texture->releaseCallback = [this, slot, bufferEvent]() {
            FreeBuffer(slot);
            bufferEvent->Signal();
        };

        buffer->texture->SynchronizeHost();

        state.gpu->presentationQueue.push(buffer->texture);

        struct {
            u32 width;
            u32 height;
            u32 _pad0_[3];
        } output{
            .width = buffer->gbpBuffer.width,
            .height = buffer->gbpBuffer.height
        };

        out.WriteData(output);

        state.logger->Debug("QueueBuffer: Timestamp: {}, Auto Timestamp: {}, Crop: [T: {}, B: {}, L: {}, R: {}], Scaling Mode: {}, Transform: {}, Sticky Transform: {}, Swap Interval: {}, Slot: {}", data->timestamp, data->autoTimestamp, data->crop.top, data->crop.bottom, data->crop.left, data->crop.right, data->scalingMode, data->transform, data->stickyTransform, data->swapInterval, data->slot);
    }

    void IHOSBinderDriver::CancelBuffer(Parcel &parcel) {
        struct Data {
            u32 slot;
            Fence fence[4];
        } *data = reinterpret_cast<Data *>(parcel.data.data());
        FreeBuffer(data->slot);
        state.logger->Debug("CancelBuffer: Slot: {}", data->slot);
    }

    void IHOSBinderDriver::SetPreallocatedBuffer(Parcel &parcel) {
        auto pointer = parcel.data.data();
        struct Data {
            u32 slot;
            u32 _unk0_;
            u32 length;
            u32 _pad0_;
        } *data = reinterpret_cast<Data *>(pointer);

        pointer += sizeof(Data);
        auto gbpBuffer = reinterpret_cast<GbpBuffer *>(pointer);

        std::shared_ptr<nvdrv::device::NvMap::NvMapObject> nvBuffer{};
        auto nvmap = state.os->serviceManager.GetService<nvdrv::INvDrvServices>(Service::nvdrv_INvDrvServices)->GetDevice<nvdrv::device::NvMap>(nvdrv::device::NvDeviceType::nvmap);

        if (gbpBuffer->nvmapHandle) {
            nvBuffer = nvmap->handleTable.at(gbpBuffer->nvmapHandle);
        } else {
            for (const auto &object : nvmap->handleTable) {
                if (object.second->id == gbpBuffer->nvmapId) {
                    nvBuffer = object.second;
                    break;
                }
            }
            if (!nvBuffer)
                throw exception("A QueueBuffer request has an invalid NVMap Handle ({}) and ID ({})", gbpBuffer->nvmapHandle, gbpBuffer->nvmapId);
        }

        gpu::texture::Format format;
        switch (gbpBuffer->format) {
            case WINDOW_FORMAT_RGBA_8888:
            case WINDOW_FORMAT_RGBX_8888:
                format = gpu::format::RGBA8888Unorm;
                break;
            case WINDOW_FORMAT_RGB_565:
                format = gpu::format::RGB565Unorm;
                break;
            default:
                throw exception("Unknown pixel format used for FB");
        }

        auto texture = std::make_shared<gpu::GuestTexture>(state, nvBuffer->address + gbpBuffer->offset, gpu::texture::Dimensions(gbpBuffer->width, gbpBuffer->height), format, gpu::texture::TileMode::Block, gpu::texture::TileConfig{.surfaceWidth = static_cast<u16>(gbpBuffer->stride), .blockHeight = static_cast<u8>(1U << gbpBuffer->blockHeightLog2), .blockDepth = 1});

        queue[data->slot] = std::make_shared<Buffer>(data->slot, *gbpBuffer, texture->InitializePresentationTexture());
        state.gpu->bufferEvent->Signal();

        state.logger->Debug("SetPreallocatedBuffer: Slot: {}, Magic: 0x{:X}, Width: {}, Height: {}, Stride: {}, Format: {}, Usage: {}, Index: {}, ID: {}, Handle: {}, Offset: 0x{:X}, Block Height: {}, Size: 0x{:X}", data->slot, gbpBuffer->magic, gbpBuffer->width, gbpBuffer->height, gbpBuffer->stride, gbpBuffer->format, gbpBuffer->usage, gbpBuffer->index, gbpBuffer->nvmapId,
                            gbpBuffer->nvmapHandle, gbpBuffer->offset, (1U << gbpBuffer->blockHeightLog2), gbpBuffer->size);
    }

    void IHOSBinderDriver::TransactParcel(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
        auto layerId = request.Pop<u32>();
        auto code = request.Pop<TransactionCode>();

        Parcel in(request.inputBuf.at(0), state, true);
        Parcel out(state);

        state.logger->Debug("TransactParcel: Layer ID: {}, Code: {}", layerId, code);

        switch (code) {
            case TransactionCode::RequestBuffer:
                RequestBuffer(in, out);
                break;
            case TransactionCode::DequeueBuffer:
                DequeueBuffer(in, out);
                break;
            case TransactionCode::QueueBuffer:
                QueueBuffer(in, out);
                break;
            case TransactionCode::CancelBuffer:
                CancelBuffer(in);
                break;
            case TransactionCode::Query:
                out.WriteData<u64>(0);
                break;
            case TransactionCode::Connect: {
                ConnectParcel connect = {
                    .width = constant::HandheldResolutionW,
                    .height = constant::HandheldResolutionH,
                    .transformHint = 0,
                    .pendingBuffers = 0,
                    .status = constant::status::Success,
                };
                out.WriteData(connect);
                break;
            }
            case TransactionCode::Disconnect:
                break;
            case TransactionCode::SetPreallocatedBuffer:
                SetPreallocatedBuffer(in);
                break;
            default:
                throw exception("An unimplemented transaction was called: {}", static_cast<u32>(code));
        }

        out.WriteParcel(request.outputBuf.at(0));
    }

    void IHOSBinderDriver::AdjustRefcount(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
        request.Skip<u32>();
        auto addVal = request.Pop<i32>();
        auto type = request.Pop<i32>();
        state.logger->Debug("Reference Change: {} {} reference", addVal, type ? "strong" : "weak");
    }

    void IHOSBinderDriver::GetNativeHandle(type::KSession &session, ipc::IpcRequest &request, ipc::IpcResponse &response) {
        KHandle handle = state.process->InsertItem(state.gpu->bufferEvent);
        state.logger->Debug("Display Buffer Event Handle: 0x{:X}", handle);
        response.copyHandles.push_back(handle);
        response.Push<u32>(constant::status::Success);
    }

    void IHOSBinderDriver::SetDisplay(const std::string &name) {
        try {
            const auto type = DisplayTypeMap.at(name);
            if (displayId == DisplayId::Null)
                displayId = type;
            else
                throw exception("Trying to change display type from non-null type");
        } catch (const std::out_of_range &) {
            throw exception("The display with name: '{}' doesn't exist", name);
        }
    }

    void IHOSBinderDriver::CloseDisplay() {
        if (displayId == DisplayId::Null)
            state.logger->Warn("Trying to close uninitiated display");
        displayId = DisplayId::Null;
    }
}