#include "gui_bridge.h"

#include <QObject>
#include <QMetaObject>
#include <QByteArray>
#include <cstring>

extern "C" {
#include "../../../lib/u_async.h"
#include "../../../lib/mem.h"
#include "../../../lib/debug_config.h"
}

/* ── Внутренний объект-приёмник в GUI-потоке ── */

class GuiBridgeReceiver : public QObject {
    Q_OBJECT
public:
    void*              ua = nullptr;

    GuiBridgeReceiver(QObject* parent = nullptr) : QObject(parent) {}

    Q_INVOKABLE void processPost(int eventType, QByteArray data);
};

static GuiBridgeReceiver*    g_receiver           = nullptr;
static gui_connect_result_fn g_connect_result_cb  = nullptr;
static gui_msg_received_fn   g_msg_received_cb    = nullptr;
static gui_channel_updated_fn  g_channel_updated_cb  = nullptr;
static gui_members_changed_fn  g_members_changed_cb  = nullptr;
static gui_my_node_id_fn       g_my_node_id_cb       = nullptr;
static gui_auto_connect_status_fn g_auto_connect_status_cb = nullptr;
static gui_channel_peers_online_fn g_channel_peers_online_cb = nullptr;
static gui_db_ready_fn          g_db_ready_cb          = nullptr;
static gui_status_refresh_fn    g_status_refresh_cb    = nullptr;
static gui_attachment_downloaded_fn g_attachment_downloaded_cb = nullptr;
static struct UASYNC*        g_ua                 = nullptr;

/* ── GuiBridgeReceiver implementation ── */

void GuiBridgeReceiver::processPost(int eventType, QByteArray data) {
    const uint8_t* d = (const uint8_t*)data.constData();
    int dlen = data.size();

    switch (eventType) {
    case GUI_EVT_MSG_RECEIVED:
        if (dlen >= 2) {
            uint8_t chLen = d[0];
            if (dlen >= 1 + chLen + 8) {
                uint64_t author = 0;
                memcpy(&author, d + 1 + chLen, 8);
                QString chId = QString::fromUtf8((const char*)d + 1, chLen);
                DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: MSG_RECEIVED ch=%s author=%llu",
                           qPrintable(chId), (unsigned long long)author);
                if (g_msg_received_cb) g_msg_received_cb((const char*)d + 1, chLen, author);
            } else {
                DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: MSG_RECEIVED invalid data length %d", dlen);
            }
        } else {
            DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: MSG_RECEIVED data too short %d", dlen);
        }
        break;
    case GUI_EVT_CONNECT_RESULT:
        if (dlen >= 20) {
            uint64_t nodeId, channelId; int result;
            memcpy(&nodeId, d, 8); memcpy(&result, d + 8, 4); memcpy(&channelId, d + 12, 8);
            DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: CONNECT_RESULT node=0x%016llx ch=%llu result=%d",
                       (unsigned long long)nodeId, (unsigned long long)channelId, result);
            if (g_connect_result_cb) g_connect_result_cb(nodeId, channelId, result);
        } else {
            DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: CONNECT_RESULT data too short %d", dlen);
        }
        break;
    case GUI_EVT_NEW_PEER:
        if (dlen >= 8) {
            uint64_t nodeId; memcpy(&nodeId, d, 8);
            DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: NEW_PEER node=0x%016llx", (unsigned long long)nodeId);
        } else {
            DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: NEW_PEER data too short %d", dlen);
        }
        break;
    case GUI_EVT_CHANNEL_UPDATED:
        if (dlen >= 2) {
            uint8_t chLen = d[0];
            if (dlen >= 1 + chLen) {
                QString chId = QString::fromUtf8((const char*)d + 1, chLen);
                DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: CHANNEL_UPDATED ch=%s", qPrintable(chId));
                if (g_channel_updated_cb) g_channel_updated_cb((const char*)d + 1, chLen);
            }
        } else {
            DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: CHANNEL_UPDATED data too short %d", dlen);
        }
        break;
    case GUI_EVT_MEMBERS_CHANGED:
        if (dlen >= 2) {
            uint8_t chLen = d[0];
            if (dlen >= 1 + chLen) {
                QString chId = QString::fromUtf8((const char*)d + 1, chLen);
                if (g_members_changed_cb) g_members_changed_cb((const char*)d + 1, chLen);
            }
        }
        break;
    case GUI_EVT_MY_NODE_ID:
        if (dlen >= 8) {
            uint64_t nid; memcpy(&nid, d, 8);
            if (g_my_node_id_cb) g_my_node_id_cb(nid);
        }
        break;
    case GUI_EVT_AUTO_CONNECT_STATUS:
        if (dlen >= 7) {
            uint8_t  status = d[0];
            uint16_t total_tried; memcpy(&total_tried, d + 1, 2);
            uint16_t node_count;  memcpy(&node_count,  d + 3, 2);
            uint16_t connected;   memcpy(&connected,   d + 5, 2);
            const char* st_str = status == 0 ? "in_progress" : status == 1 ? "done" : "stopped";
            if (status != 0) DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: AUTO_CONNECT %s tried=%u/%u connected=%u", st_str, total_tried, node_count, connected);
            if (g_auto_connect_status_cb) g_auto_connect_status_cb(status, total_tried, node_count, connected);
        }
        break;
    case GUI_EVT_CHANNEL_PEERS_ONLINE:
        if (dlen >= 3) {
            uint8_t chLen = d[0];
            if (dlen >= 3 + chLen) {
                uint16_t online; memcpy(&online, d + 1 + chLen, 2);
                DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: CHANNEL_PEERS_ONLINE ch=%.*s online=%u", chLen, (const char*)d + 1, online);
                if (g_channel_peers_online_cb) g_channel_peers_online_cb((const char*)d + 1, chLen, online);
            }
        }
        break;
    case GUI_EVT_DB_READY:
        DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: DB_READY");
        if (g_db_ready_cb) g_db_ready_cb();
        break;
    case GUI_EVT_STATUS_REFRESH:
        if (g_status_refresh_cb) g_status_refresh_cb((const char*)d, dlen);
        break;
    case GUI_EVT_NODE_CHANGED:
        if (dlen >= 8) {
            uint64_t nodeId; memcpy(&nodeId, d, 8);
            DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: NODE_CHANGED node=0x%016llx — pubkey changed, connection closed", (unsigned long long)nodeId);
        } else {
            DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: NODE_CHANGED data too short %d", dlen);
        }
        break;
    case GUI_EVT_ATTACHMENT_DOWNLOADED:
        if (dlen >= 2) {
            uint8_t chLen = d[0];
            if (dlen >= 1 + chLen + 8) {
                int64_t msgId = 0; memcpy(&msgId, d + 1 + chLen, 8);
                DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge: ATTACHMENT_DOWNLOADED ch=%.*s msgId=%lld", chLen, (const char*)d + 1, (long long)msgId);
                if (g_attachment_downloaded_cb) g_attachment_downloaded_cb((const char*)d + 1, chLen, msgId);
            }
        }
        break;
    default:
        DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge: unknown event type %d", eventType);
        break;
    }
}

/* ── C API ── */

extern "C" {

void gui_bridge_init(void) {
    g_receiver = new GuiBridgeReceiver();
    g_receiver->ua = g_ua;
}

void gui_bridge_set_uasync(struct UASYNC* ua) {
    g_ua = ua;
    if (g_receiver) g_receiver->ua = ua;
}

void gui_bridge_post(int event_type, const uint8_t* data, int data_len) {
    if (!g_receiver) { DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge_post: g_receiver=NULL, dropping event %d", event_type); return; }

    QByteArray d;
    if (data_len > 0) d = QByteArray((const char*)data, data_len);

    QMetaObject::invokeMethod(g_receiver, "processPost",
        Qt::QueuedConnection,
        Q_ARG(int, event_type),
        Q_ARG(QByteArray, d));
}

void gui_bridge_post_uasync_fn(void (*fn)(void*), void* arg) {
    if (!g_ua) {
        DEBUG_WARN(DEBUG_CATEGORY_DEBUG, "gui_bridge_post_uasync_fn: g_ua=NULL, post dropped");
        return;
    }
    if (!fn) return;
    uasync_post(g_ua, fn, arg);
    DEBUG_INFO(DEBUG_CATEGORY_DEBUG, "gui_bridge_post_uasync_fn: posted fn=%p arg=%p", (void*)fn, arg);
}

int gui_bridge_is_uasync_ready(void) {
    return g_ua != NULL ? 1 : 0;
}

void gui_bridge_set_connect_result_cb(gui_connect_result_fn cb) {
    g_connect_result_cb = cb;
}

void gui_bridge_set_msg_received_cb(gui_msg_received_fn cb) {
    g_msg_received_cb = cb;
}

void gui_bridge_set_channel_updated_cb(gui_channel_updated_fn cb) {
    g_channel_updated_cb = cb;
}

void gui_bridge_set_members_changed_cb(gui_members_changed_fn cb) {
    g_members_changed_cb = cb;
}

void gui_bridge_set_my_node_id_cb(gui_my_node_id_fn cb) {
    g_my_node_id_cb = cb;
}

void gui_bridge_set_auto_connect_status_cb(gui_auto_connect_status_fn cb) {
    g_auto_connect_status_cb = cb;
}

void gui_bridge_set_channel_peers_online_cb(gui_channel_peers_online_fn cb) {
    g_channel_peers_online_cb = cb;
}

void gui_bridge_set_db_ready_cb(gui_db_ready_fn cb) {
    g_db_ready_cb = cb;
}

void gui_bridge_set_status_refresh_cb(gui_status_refresh_fn cb) {
    g_status_refresh_cb = cb;
}

void gui_bridge_set_attachment_downloaded_cb(gui_attachment_downloaded_fn cb) {
    g_attachment_downloaded_cb = cb;
}

} /* extern "C" */

#include "gui_bridge_impl.moc"