// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "coreprotocol.h"
#include "datadevice.h"

namespace MockCompositor {

Surface::Surface(WlCompositor *wlCompositor, wl_client *client, int id, int version)
    : QtWaylandServer::wl_surface(client, id, version)
    , m_wlCompositor(wlCompositor)
    , m_wlshell(wlCompositor->m_compositor->m_type == CoreCompositor::CompositorType::Legacy)
{
}

Surface::~Surface()
{
    // TODO: maybe make sure buffers are released?
    qDeleteAll(m_commits);
    if (m_wlShellSurface)
        m_wlShellSurface->m_surface = nullptr;
    delete m_role;
}

void Surface::sendFrameCallbacks()
{
    uint time = m_wlCompositor->m_compositor->currentTimeMilliseconds();
    for (auto *callback : m_waitingFrameCallbacks)
        callback->sendDone(time);
    m_waitingFrameCallbacks.clear();
}

void Surface::sendEnter(Output *output)
{
    m_outputs.append(output);
    const auto outputResources = output->resourceMap().values(resource()->client());
    for (auto outputResource: outputResources)
        wl_surface::send_enter(resource()->handle, outputResource->handle);
}

void Surface::sendLeave(Output *output)
{
    m_outputs.removeOne(output);
    const auto outputResources = output->resourceMap().values(resource()->client());
    for (auto outputResource: outputResources)
        wl_surface::send_leave(resource()->handle, outputResource->handle);
}

void Surface::map()
{
    m_mapped = true;
}

void Surface::unmap()
{
    m_mapped = false;
}

void Surface::surface_destroy_resource(Resource *resource)
{
    Q_UNUSED(resource);
    for (auto *commit : m_commits)
        delete commit->commitSpecific.frame;
    bool removed = m_wlCompositor->m_surfaces.removeOne(this);
    Q_ASSERT(removed);
    delete this;
}

void Surface::surface_destroy(Resource *resource)
{
    if (m_wlShellSurface) // on wl-shell the shell surface is automatically destroyed with the surface
        wl_resource_destroy(m_wlShellSurface->resource()->handle);
    Q_ASSERT(!m_wlShellSurface);
    wl_resource_destroy(resource->handle);
}

void Surface::surface_attach(Resource *resource, wl_resource *buffer, int32_t x, int32_t y)
{
    Q_UNUSED(resource);
    if (m_wlshell) {
        m_buffer = buffer;
        if (!buffer) {
            m_image = QImage();
            unmap();
        }
    } else {
        QPoint offset(x, y);
        if (resource->version() < 5)
            m_pending.commitSpecific.attachOffset = offset;

        m_pending.buffer = fromResource<Buffer>(buffer);
        m_pending.commitSpecific.attached = true;

        emit attach(buffer, offset);
    }
}

void Surface::surface_set_buffer_scale(QtWaylandServer::wl_surface::Resource *resource, int32_t scale)
{
    Q_UNUSED(resource);
    m_pending.bufferScale = scale;
}

void Surface::surface_commit(Resource *resource)
{
    Q_UNUSED(resource);

    if (m_wlshell) {
        if (m_buffer) {
            struct ::wl_shm_buffer *shm_buffer = wl_shm_buffer_get(m_buffer);
            if (shm_buffer) {
                int stride = wl_shm_buffer_get_stride(shm_buffer);
                uint format = wl_shm_buffer_get_format(shm_buffer);
                Q_UNUSED(format);
                void *data = wl_shm_buffer_get_data(shm_buffer);
                const uchar *char_data = static_cast<const uchar *>(data);
                QImage img(char_data, wl_shm_buffer_get_width(shm_buffer), wl_shm_buffer_get_height(shm_buffer), stride, QImage::Format_ARGB32_Premultiplied);
                m_image = img;
            }
        }

        for (wl_resource *frameCallback : std::exchange(m_frameCallbackList, {})) {
            auto time = m_wlCompositor->m_compositor->currentTimeMilliseconds();
            wl_callback_send_done(frameCallback, time);
            wl_resource_destroy(frameCallback);
        }
    } else {
        m_committed = m_pending;
        m_commits.append(new DoubleBufferedState(m_committed));

        if (auto *frame = m_pending.commitSpecific.frame)
            m_waitingFrameCallbacks.append(frame);

        m_pending.commitSpecific = PerCommitData();
        emit commit();
        if (m_committed.commitSpecific.attached)
            emit bufferCommitted();
    }
}

void Surface::surface_frame(Resource *resource, uint32_t callback)
{
    if (m_wlshell) {
        wl_resource *frameCallback = wl_resource_create(resource->client(), &wl_callback_interface, 1, callback);
        m_frameCallbackList << frameCallback;
    } else {
        // Although valid, there is really no point having multiple frame requests in the same commit.
        // Make sure we don't do it
        QCOMPARE(m_pending.commitSpecific.frame, nullptr);

        auto *frame = new Callback(resource->client(), callback, 1);
        m_pending.commitSpecific.frame = frame;
    }
}

void Surface::surface_offset(Resource *resource, int32_t x, int32_t y)
{
    Q_UNUSED(resource);
    QPoint offset(x, y);
    m_pending.commitSpecific.attachOffset = offset;
}

bool WlCompositor::isClean() {
    for (auto *surface : std::as_const(m_surfaces)) {
        if (!CursorRole::fromSurface(surface)) {
            if (surface->isMapped())
                return false;
        }
    }
    return true;
}

QString WlCompositor::dirtyMessage()
{
    if (isClean())
        return "clean";
    QStringList messages;
    for (auto *s : std::as_const(m_surfaces)) {
        QString role = s->m_role ? s->m_role->staticMetaObject.className(): "none/unknown";
        messages << "Surface with role: " + role;
    }
    return "Dirty, surfaces left:\n\t" + messages.join("\n\t");
}

void SubCompositor::subcompositor_get_subsurface(Resource *resource, uint32_t id,
                                                 ::wl_resource *surfaceResource,
                                                 ::wl_resource *parent)
{
    QTRY_VERIFY(parent);
    QTRY_VERIFY(surfaceResource);
    auto surface = fromResource<Surface>(surfaceResource);
    if (!surface->m_role) {
        surface->m_role = new SubSurfaceRole;
    } else if (!qobject_cast<SubSurfaceRole *>(surface->m_role)) {
        QFAIL(QByteArrayLiteral("surface already has role") + surface->m_role->metaObject()->className());
        return;
    }

    auto *subsurface = new Subsurface(this, resource->client(), id, resource->version());
    m_subsurfaces.append(subsurface);
    emit subsurfaceCreated(subsurface);
}

void Output::sendGeometry()
{
    const auto resources = resourceMap().values();
    for (auto r : resources)
        sendGeometry(r);
}

void Output::sendGeometry(Resource *resource)
{
    // TODO: check resource version as well?
    wl_output::send_geometry(resource->handle,
                             m_data.position.x(), m_data.position.y(),
                             m_data.physicalSize.width(), m_data.physicalSize.height(),
                             m_data.subpixel, m_data.make, m_data.model, m_data.transform);
}

void Output::sendScale(int factor)
{
    Q_ASSERT(m_version >= WL_OUTPUT_SCALE_SINCE_VERSION);
    m_data.scale = factor;
    const auto resources = resourceMap().values();
    for (auto r : resources)
        sendScale(r);
}

void Output::sendScale(Resource *resource)
{
    Q_ASSERT(m_version >= WL_OUTPUT_SCALE_SINCE_VERSION);
    // TODO: check resource version as well?
    wl_output::send_scale(resource->handle, m_data.scale);
}

void Output::sendDone(wl_client *client)
{
    Q_ASSERT(m_version >= WL_OUTPUT_DONE_SINCE_VERSION);
    auto resources = resourceMap().values(client);
    for (auto *r : resources)
        wl_output::send_done(r->handle);
}

void Output::sendDone()
{
    Q_ASSERT(m_version >= WL_OUTPUT_DONE_SINCE_VERSION);
    // TODO: check resource version as well?
    const auto resources = resourceMap().values();
    for (auto r : resources)
        wl_output::send_done(r->handle);
}

void Output::output_bind_resource(QtWaylandServer::wl_output::Resource *resource)
{
    sendGeometry(resource);
    send_mode(resource->handle, mode_preferred | mode_current,
              m_data.mode.resolution.width(), m_data.mode.resolution.height(), m_data.mode.refreshRate);
    if (m_version >= WL_OUTPUT_SCALE_SINCE_VERSION)
        sendScale(resource);

    if (m_version >= WL_OUTPUT_DONE_SINCE_VERSION)
        wl_output::send_done(resource->handle);

    Q_EMIT outputBound(resource);
}

// Seat stuff
Seat::Seat(CoreCompositor *compositor, uint capabilities, int version, const QString &seatName) //TODO: check version
    : QtWaylandServer::wl_seat(compositor->m_display, version)
    , m_seatName(seatName)
    , m_compositor(compositor)
{
    setCapabilities(capabilities);
}

Seat::~Seat()
{
    qDeleteAll(m_oldPointers);
    delete m_pointer;

    qDeleteAll(m_oldTouchs);
    delete m_touch;

    qDeleteAll(m_oldKeyboards);
    delete m_keyboard;
}

void Seat::setCapabilities(uint capabilities) {
    m_capabilities = capabilities;

    if (m_capabilities & capability_pointer) {
        if (!m_pointer)
            m_pointer = (new Pointer(this));
    } else if (m_pointer) {
        m_oldPointers << m_pointer;
        m_pointer = nullptr;
    }

    if (m_capabilities & capability_touch) {
        if (!m_touch)
            m_touch = (new Touch(this));
    } else if (m_touch) {
        m_oldTouchs << m_touch;
        m_touch = nullptr;
    }

    if (m_capabilities & capability_keyboard) {
        if (!m_keyboard)
            m_keyboard = (new Keyboard(this));
    } else if (m_keyboard) {
        m_oldKeyboards << m_keyboard;
        m_keyboard = nullptr;
    }

    for (auto *resource : resourceMap())
        wl_seat::send_capabilities(resource->handle, capabilities);
}

void Seat::seat_get_pointer(Resource *resource, uint32_t id)
{
    if (~m_capabilities & capability_pointer) {
        qWarning() << "Client requested a wl_pointer without the capability being available."
                   << "This Could be a race condition when hotunplugging,"
                   << "but is most likely a client error";
        Pointer *pointer = new Pointer(this);
        pointer->add(resource->client(), id, resource->version());
        // TODO: mark as destroyed
        m_oldPointers << pointer;
        return;
    }
    m_pointer->add(resource->client(), id, resource->version());
}

void Seat::seat_get_touch(QtWaylandServer::wl_seat::Resource *resource, uint32_t id)
{
    if (~m_capabilities & capability_touch) {
        qWarning() << "Client requested a wl_touch without the capability being available."
                   << "This Could be a race condition when hotunplugging,"
                   << "but is most likely a client error";
        Touch *touch = new Touch(this);
        touch->add(resource->client(), id, resource->version());
        // TODO: mark as destroyed
        m_oldTouchs << touch;
        return;
    }
    m_touch->add(resource->client(), id, resource->version());
}

void Seat::seat_get_keyboard(QtWaylandServer::wl_seat::Resource *resource, uint32_t id)
{
    if (~m_capabilities & capability_keyboard) {
        qWarning() << "Client requested a wl_keyboard without the capability being available."
                   << "This Could be a race condition when hotunplugging,"
                   << "but is most likely a client error";
        Keyboard *keyboard = new Keyboard(this);
        keyboard->add(resource->client(), id, resource->version());
        // TODO: mark as destroyed
        m_oldKeyboards << keyboard;
        return;
    }
    m_keyboard->add(resource->client(), id, resource->version());
}

Surface *Pointer::cursorSurface()
{
    return m_cursorRole ? m_cursorRole->m_surface : nullptr;
}

uint Pointer::sendEnter(Surface *surface, const QPointF &position)
{
    wl_fixed_t x = wl_fixed_from_double(position.x());
    wl_fixed_t y = wl_fixed_from_double(position.y());

    uint serial = m_seat->m_compositor->nextSerial();
    m_enterSerials << serial;
    m_cursorRole.clear(); // According to the protocol, the pointer image is undefined after enter

    wl_client *client = surface->resource()->client();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources) {
        wl_pointer::send_enter(r->handle, serial, surface->resource()->handle, x ,y);
    }
    return serial;
}

uint Pointer::sendLeave(Surface *surface)
{
    uint serial = m_seat->m_compositor->nextSerial();

    wl_client *client = surface->resource()->client();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        wl_pointer::send_leave(r->handle, serial, surface->resource()->handle);
    return serial;
}

// Make sure you call enter, frame etc. first
void Pointer::sendMotion(wl_client *client, const QPointF &position)
{
    wl_fixed_t x = wl_fixed_from_double(position.x());
    wl_fixed_t y = wl_fixed_from_double(position.y());
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_motion(r->handle, time, x, y);
}

// Make sure you call enter, frame etc. first
uint Pointer::sendButton(wl_client *client, uint button, uint state)
{
    Q_ASSERT(state == button_state_pressed || state == button_state_released);
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    uint serial = m_seat->m_compositor->nextSerial();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_button(r->handle, serial, time, button, state);
    return serial;
}

// Make sure you call enter, frame etc. first
void Pointer::sendAxis(wl_client *client, axis axis, qreal value)
{
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    wl_fixed_t val = wl_fixed_from_double(value);
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis(r->handle, time, axis, val);
}

void Pointer::sendAxisDiscrete(wl_client *client, QtWaylandServer::wl_pointer::axis axis, int discrete)
{
    // TODO: assert v5 or newer
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis_discrete(r->handle, axis, discrete);
}

void Pointer::sendAxisSource(wl_client *client, QtWaylandServer::wl_pointer::axis_source source)
{
    // TODO: assert v5 or newer
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis_source(r->handle, source);
}

void Pointer::sendAxisStop(wl_client *client, QtWaylandServer::wl_pointer::axis axis)
{
    // TODO: assert v5 or newer
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis_stop(r->handle, time, axis);
}

void Pointer::sendFrame(wl_client *client)
{
    //TODO: assert version 5 or newer?
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_frame(r->handle);
}

void Pointer::sendAxisValue120(wl_client *client, QtWaylandServer::wl_pointer::axis axis, int value120)
{
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis_value120(r->handle, axis, value120);
}

void Pointer::sendAxisRelativeDirection(wl_client *client, QtWaylandServer::wl_pointer::axis axis, QtWaylandServer::wl_pointer::axis_relative_direction direction)
{
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_axis_relative_direction(r->handle, axis, direction);
}

void Pointer::pointer_set_cursor(Resource *resource, uint32_t serial, wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y)
{
    Q_UNUSED(resource);

    if (!surface) {
        m_cursorRole = nullptr;
    } else {
        auto *s = fromResource<Surface>(surface);
        QVERIFY(s);
        if (s->m_role) {
            m_cursorRole = CursorRole::fromSurface(s);
            QVERIFY(m_cursorRole);
        } else {
            m_cursorRole = new CursorRole(s); //TODO: make sure we don't leak CursorRole
            s->m_role = m_cursorRole;
        }
    }

    // Directly checking the last serial would be racy, we may just have sent leaves/enters which
    // the client hasn't yet seen. Instead just check if the serial matches an enter serial since
    // the last time the client sent a set_cursor request.
    QVERIFY(m_enterSerials.contains(serial));
    while (m_enterSerials.first() < serial) { m_enterSerials.removeFirst(); }

    m_hotspot = QPoint(hotspot_x, hotspot_y);
    emit setCursor(serial);
}

uint Touch::sendDown(Surface *surface, const QPointF &position, int id)
{
    wl_fixed_t x = wl_fixed_from_double(position.x());
    wl_fixed_t y = wl_fixed_from_double(position.y());
    uint serial = m_seat->m_compositor->nextSerial();
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    wl_client *client = surface->resource()->client();

    const auto touchResources = resourceMap().values(client);
    for (auto *r : touchResources)
        wl_touch::send_down(r->handle, serial, time, surface->resource()->handle, id, x, y);

    return serial;
}

uint Touch::sendUp(wl_client *client, int id)
{
    uint serial = m_seat->m_compositor->nextSerial();
    auto time = m_seat->m_compositor->currentTimeMilliseconds();

    const auto touchResources = resourceMap().values(client);
    for (auto *r : touchResources)
        wl_touch::send_up(r->handle, serial, time, id);

    return serial;
}

void Touch::sendMotion(wl_client *client, const QPointF &position, int id)
{
    wl_fixed_t x = wl_fixed_from_double(position.x());
    wl_fixed_t y = wl_fixed_from_double(position.y());

    auto time = m_seat->m_compositor->currentTimeMilliseconds();

    const auto touchResources = resourceMap().values(client);
    for (auto *r : touchResources)
        wl_touch::send_motion(r->handle, time, id, x, y);
}

void Touch::sendFrame(wl_client *client)
{
    const auto touchResources = resourceMap().values(client);
    for (auto *r : touchResources)
        send_frame(r->handle);
}

void Touch::sendCancel(wl_client *client)
{
    const auto touchResources = resourceMap().values(client);
    for (auto *r : touchResources)
        send_cancel(r->handle);
}

uint Keyboard::sendEnter(Surface *surface)
{
    auto serial = m_seat->m_compositor->nextSerial();
    wl_client *client = surface->resource()->client();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_enter(r->handle, serial, surface->resource()->handle, QByteArray());
    m_enteredSurface = surface;
    return serial;
}

uint Keyboard::sendLeave(Surface *surface)
{
    auto serial = m_seat->m_compositor->nextSerial();
    wl_client *client = surface->resource()->client();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources)
        send_leave(r->handle, serial, surface->resource()->handle);
    m_enteredSurface = nullptr;
    return serial;
}

uint Keyboard::sendKey(wl_client *client, uint key, uint state)
{
    Q_ASSERT(state == key_state_pressed || state == key_state_released);
    auto time = m_seat->m_compositor->currentTimeMilliseconds();
    uint serial = m_seat->m_compositor->nextSerial();
    const auto pointerResources = resourceMap().values(client);
    for (auto *r : pointerResources) {
        send_key(r->handle, serial, time, key, state);
    }
    return serial;
}

// Shm implementation
Shm::Shm(CoreCompositor *compositor, QList<format> formats, int version)
    : QtWaylandServer::wl_shm(compositor->m_display, version)
    , m_compositor(compositor)
    , m_formats(formats)
{
    // Some formats are specified as mandatory
    Q_ASSERT(m_formats.contains(format_argb8888));
    Q_ASSERT(m_formats.contains(format_xrgb8888));
}

bool Shm::isClean()
{
//    for (ShmPool *pool : std::as_const(m_pools)) {
//        //TODO: return false if not cursor buffer
//        if (pool->m_buffers.isEmpty()) {
//            return false;
//        }
//    }
    return true;
}

void Shm::shm_create_pool(Resource *resource, uint32_t id, int32_t fd, int32_t size)
{
    Q_UNUSED(fd);
    Q_UNUSED(size);
    auto *pool = new ShmPool(this, resource->client(), id, 1);
    m_pools.append(pool);
}

ShmPool::ShmPool(Shm *shm, wl_client *client, int id, int version)
    : QtWaylandServer::wl_shm_pool(client, id, version)
    , m_shm(shm)
{
}

void ShmPool::shm_pool_create_buffer(Resource *resource, uint32_t id, int32_t offset, int32_t width, int32_t height, int32_t stride, uint32_t format)
{
    QSize size(width, height);
    new ShmBuffer(offset, size, stride, Shm::format(format), resource->client(), id);
}

void ShmPool::shm_pool_destroy_resource(Resource *resource)
{
    Q_UNUSED(resource);
    bool removed = m_shm->m_pools.removeOne(this);
    Q_ASSERT(removed);
    delete this;
}

WlShell::WlShell(CoreCompositor *compositor, int version)
    : QtWaylandServer::wl_shell(compositor->m_display, version)
    , m_compositor(compositor)
{
}

void WlShell::shell_get_shell_surface(Resource *resource, uint32_t id, wl_resource *surface)
{
    auto *s = fromResource<Surface>(surface);
    if (!s->m_role) {
        s->m_role = new WlShellSurfaceRole;
    } else if (!qobject_cast<WlShellSurfaceRole *>(s->m_role)) {
        QFAIL(QByteArrayLiteral("surface already has role") + s->m_role->metaObject()->className());
        return;
    }

    auto *wlShellSurface = new WlShellSurface(this, resource->client(), id, s);
    m_wlShellSurfaces << wlShellSurface;
    emit wlShellSurfaceCreated(wlShellSurface);
}

WlShellSurface::WlShellSurface(WlShell *wlShell, wl_client *client, int id, Surface *surface)
    : QtWaylandServer::wl_shell_surface(client, id, 1)
    , m_wlShell(wlShell)
    , m_surface(surface)
{
    surface->m_wlShellSurface = this;
    surface->map();
}

WlShellSurface::~WlShellSurface()
{
    if (m_surface) {
        m_surface->unmap();
        m_surface->m_wlShellSurface = nullptr;
    }
}

void WlShellSurface::sendConfigure(uint32_t edges, int32_t width, int32_t height)
{
    wl_shell_surface::send_configure(edges, width, height);
}

} // namespace MockCompositor
