/*
    KWin - the KDE window manager
    This file is part of the KDE project.

    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
    SPDX-FileCopyrightText: 2025 Vlad Zahorodnii <vlad.zahorodnii@kde.org>

    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once

#include "utils/filedescriptor.h"

#include <QList>
#include <QObject>
#include <QSocketNotifier>

#include <xcb/xcb.h>

namespace KWin
{
namespace Xwl
{

/**
 * Represents for an arbitrary selection a data transfer between
 * sender and receiver.
 *
 * Lives for the duration of the transfer and must be cleaned up
 * externally afterwards. For that the owner should connect to the
 * @c finished() signal.
 */
class Transfer : public QObject
{
    Q_OBJECT

public:
    Transfer(xcb_atom_t selection, FileDescriptor fd, xcb_timestamp_t timestamp, QObject *parent = nullptr);

    virtual bool handlePropertyNotify(xcb_property_notify_event_t *event) = 0;
    void timeout();
    xcb_timestamp_t timestamp() const
    {
        return m_timestamp;
    }

Q_SIGNALS:
    void finished();

protected:
    void endTransfer();

    xcb_atom_t atom() const
    {
        return m_atom;
    }
    qint32 fd() const
    {
        return m_fd.get();
    }

    void setIncr(bool set)
    {
        m_incr = set;
    }
    bool incr() const
    {
        return m_incr;
    }
    void resetTimeout()
    {
        m_timeout = false;
    }
    void createSocketNotifier(QSocketNotifier::Type type);
    void clearSocketNotifier();
    QSocketNotifier *socketNotifier() const
    {
        return m_notifier.get();
    }

private:
    xcb_atom_t m_atom;
    xcb_timestamp_t m_timestamp = XCB_CURRENT_TIME;
    FileDescriptor m_fd;

    std::unique_ptr<QSocketNotifier> m_notifier;
    bool m_incr = false;
    bool m_timeout = false;

    Q_DISABLE_COPY(Transfer)
};

/**
 * Represents a transfer from a Wayland native source to an X window.
 */
class TransferWltoX : public Transfer
{
    Q_OBJECT

public:
    TransferWltoX(const xcb_selection_request_event_t &request, FileDescriptor fd, QObject *parent = nullptr);

    void startTransferFromSource();
    bool handlePropertyNotify(xcb_property_notify_event_t *event) override;

private:
    void startIncr();
    void readWlSource();
    int flushSourceData();
    void handlePropertyDelete();

    xcb_selection_request_event_t m_request;

    /* contains all received data portioned in chunks
     * TODO: explain second QPair component
     */
    QList<QPair<QByteArray, int>> m_chunks;

    bool m_propertyIsSet = false;
    bool m_flushPropertyOnDelete = false;

    Q_DISABLE_COPY(TransferWltoX)
};

/**
 * Helper class for X to Wl transfers.
 */
class DataReceiver
{
public:
    virtual ~DataReceiver();

    void transferFromProperty(xcb_get_property_reply_t *reply);

    void setData(const char *value, int length);
    QByteArray data() const;

    void partRead(int length);

private:
    xcb_get_property_reply_t *m_propertyReply = nullptr;
    int m_propertyStart = 0;
    QByteArray m_data;
};

/**
 * Represents a transfer from an X window to a Wayland native client.
 */
class TransferXtoWl : public Transfer
{
    Q_OBJECT

public:
    TransferXtoWl(xcb_atom_t selection, xcb_atom_t target, FileDescriptor fd, xcb_timestamp_t timestamp, xcb_window_t parentWindow, QObject *parent = nullptr);
    ~TransferXtoWl() override;

    bool handleSelectionNotify(xcb_selection_notify_event_t *event);
    bool handlePropertyNotify(xcb_property_notify_event_t *event) override;

private:
    void dataSourceWrite();
    void startTransfer();
    void getIncrChunk();

    xcb_window_t m_window;
    DataReceiver *m_receiver = nullptr;

    Q_DISABLE_COPY(TransferXtoWl)
};

} // namespace Xwl
} // namespace KWin
