#include <iostream>
#include <random>
#include <string>
#include <QApplication>
#include <QByteArray>
#include <QDBusConnection>
#include <QDBusInterface>
#include <QDBusReply>
#include <QObject>
#include <QTimer>

inline QLatin1String operator"" _qls(const char *s, std::size_t len) noexcept
{
    return QLatin1String(s, len);
}

class DBusTest : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("D-Bus Interface", "com.mi.EasyViz.DBusTest");

public:
    explicit DBusTest(QObject *parent = nullptr) : QObject(parent)
    {
        auto bus = QDBusConnection::sessionBus();
        bus.registerObject("/DBusTest"_qls, this, QDBusConnection::ExportAllContents);
        bus.registerService("com.mi.EasyViz.DBusTest"_qls);
    }

public Q_SLOTS:
    QByteArray testReturn(int size)
    {
        QByteArray ba(size, 'x');
        return ba;
    }

    Q_NOREPLY void emit(QByteArray ba)
    {
        std::cout << "emitting signal with " << ba.size() << " bytes\n";
        Q_EMIT testSignal(ba);
    }

Q_SIGNALS:
    void testSignal(const QByteArray &ba);
};

class Receiver : public QObject
{
    Q_OBJECT;

public Q_SLOTS:
    void handleSignal(QDBusMessage msg)
    {
        std::cout << "Signal handler called\n";
        switch (msg.type()) {
        case QDBusMessage::SignalMessage:
            std::cout << "Signal received. Argument is "
                      << msg.arguments()[0].toByteArray().size() << " bytes\n";
            break;
        case QDBusMessage::ErrorMessage:
            std::cerr << "ERROR receiving signal: " << qPrintable(msg.errorName()) << '\n';
            break;
        default:
            throw 42;
        }
    }
};

template <typename T>
void check(QDBusReply<T> r)
{
    if (!r.isValid()) {
        std::cerr << "Got an invalid DBusReply: " << qPrintable(r.error().name()) << "\n";
        abort();
    }
}

int client()
{
    QDBusInterface proxy("com.mi.EasyViz.DBusTest"_qls, "/DBusTest"_qls, {},
                         QDBusConnection::sessionBus(), nullptr);

    Receiver rcv;
    QDBusConnection::sessionBus().connect("com.mi.EasyViz.DBusTest"_qls, "/DBusTest"_qls, {},
                                          "testSignal"_qls, &rcv, SLOT(handleSignal(QDBusMessage)));

    std::vector<std::function<void()>> funcs{
        [&]() { proxy.call("emit"_qls, QByteArray(10000000, 'x')); },
        [&]() { check<QByteArray>(proxy.call("testReturn"_qls, 10000000)); },
    };

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, funcs.size() - 1);

    QTimer timer;
    QObject::connect(&timer, &QTimer::timeout, [&]() {
        const auto num = dis(gen);
            funcs.at(num)();
    });

    timer.start(1);

    return qApp->exec();
}

int server()
{
    DBusTest server;
    return qApp->exec();
}

int main(int argc, char **argv)
{
//    qInstallMessageHandler([](auto type, const auto&, auto msg) { abort(); });
    QApplication app(argc, argv);

    if (argc == 1) {
        std::cout << "-l or -c\n";
        return 0;
    }

    if (argv[1] == std::string("-c")) {
        std::cout << "Connecting\n";
        return client();
    }
    if (argv[1] == std::string("-l")) {
        std::cout << "Listening\n";
        return server();
    }
}

#include "dbustest.moc"