#include <stdlib.h>
#include <string.h>
#include <stdint.h>

#include "../lib/ll_queue.h"
#include "../lib/debug_config.h"
#include "../lib/mem.h"
#include "../lib/memory_pool.h"
#include "utun_instance.h"
#include "etcp.h"
#include "config_parser.h"
#include "route_node.h"
#include "route_bgp.h"
#include "route_lib.h"
#include "etcp_debug.h"

void nodeinfo_ref(struct NODEINFO* ni) {
    if (!ni) return;
    ni->ref_count++;
}

void nodeinfo_unref(struct NODEINFO* ni) {
    if (!ni) return;
    if (--ni->ref_count == 0) {
        u_free(ni->node_name);
        u_free(ni);
    }
}

static void free_v4_sock_list(struct memory_pool* pool, struct NI_IPV4_SOCKET_META* head) {
    while (head) { struct NI_IPV4_SOCKET_META* next = head->next; memory_pool_free(pool, head); head = next; }
}
static void free_v4_addr_list(struct memory_pool* pool, struct NI_IPV4_ADDR* head) {
    while (head) { struct NI_IPV4_ADDR* next = head->next; memory_pool_free(pool, head); head = next; }
}
static void free_v6_sock_list(struct memory_pool* pool, struct NI_IPV6_SOCKET_META* head) {
    while (head) { struct NI_IPV6_SOCKET_META* next = head->next; memory_pool_free(pool, head); head = next; }
}
static void free_v6_addr_list(struct memory_pool* pool, struct NI_IPV6_ADDR* head) {
    while (head) { struct NI_IPV6_ADDR* next = head->next; memory_pool_free(pool, head); head = next; }
}
static void free_v4_sub_list(struct memory_pool* pool, struct NI_IPV4_SUBNET* head) {
    while (head) { struct NI_IPV4_SUBNET* next = head->next; memory_pool_free(pool, head); head = next; }
}
static void free_v6_sub_list(struct memory_pool* pool, struct NI_IPV6_SUBNET* head) {
    while (head) { struct NI_IPV6_SUBNET* next = head->next; memory_pool_free(pool, head); head = next; }
}

void nodeinfo_free_lists(struct ROUTE_BGP* bgp, struct NODEINFO_Q* nq) {
    if (!bgp || !nq) return;
    if (nq->node) {
        free_v4_sock_list(bgp->v4_sock_meta_pool, nq->node->v4_sock_meta);
        free_v4_addr_list(bgp->v4_addr_pool, nq->node->v4_addrs);
        free_v6_sock_list(bgp->v6_sock_meta_pool, nq->node->v6_sock_meta);
        free_v6_addr_list(bgp->v6_addr_pool, nq->node->v6_addrs);
        nq->node->v4_sock_meta = NULL; nq->node->v4_addrs = NULL;
        nq->node->v6_sock_meta = NULL; nq->node->v6_addrs = NULL;
        nodeinfo_unref(nq->node);
        nq->node = NULL;
    }
    if (nq->routes) {
        free_v4_sub_list(bgp->v4_subnet_pool, nq->routes->v4_subnets);
        free_v6_sub_list(bgp->v6_subnet_pool, nq->routes->v6_subnets);
        u_free(nq->routes);
        nq->routes = NULL;
    }
    u_free(nq->tranzit_data); nq->tranzit_data = NULL; nq->tranzit_count = 0;
    u_free(nq->hop_list); nq->hop_list = NULL; nq->hop_count = 0;
}

// ===== serialization =====

int nodeinfo_dyn_size(const struct NODEINFO_MSG* msg) {
    return   msg->node_name_len
           + msg->local_v4_sockets * sizeof(struct NODEINFO_IPV4_SOCKET_META)
           + msg->local_v4_addrs   * sizeof(struct NODEINFO_IPV4_ADDR)
           + msg->local_v6_sockets * sizeof(struct NODEINFO_IPV6_SOCKET_META)
           + msg->local_v6_addrs   * sizeof(struct NODEINFO_IPV6_ADDR)
           + ((msg->flags & NODEINFO_FLAG_SEND_SUBNETS)
              ? (msg->local_v4_subnets * sizeof(struct NODEINFO_IPV4_SUBNET) + msg->local_v6_subnets * sizeof(struct NODEINFO_IPV6_SUBNET))
              : 0)
           + msg->tranzit_nodes * sizeof(struct NODEINFO_TRANZIT_NODE)
           + msg->hop_count * 8;
}

int nodeinfo_serialize(struct ROUTE_BGP* bgp, struct NODEINFO_Q* nq, uint8_t* out, size_t out_max) {
    if (!bgp || !nq || !nq->node || !out) return -1;
    struct NODEINFO* ni = nq->node;

    struct NODEINFO_MSG msg;
    memset(&msg, 0, sizeof(msg));
    msg.flags           = ni->flags;
    msg.group_id        = ni->group_id;
    msg.node_id         = ni->node_id;
    msg.ver             = ni->ver;
    memcpy(msg.public_key, ni->public_key, SC_PUBKEY_SIZE);
    memcpy(msg.ed25519_public_key, ni->ed25519_public_key, SC_PUBKEY_SIZE);
    msg.node_name_len   = ni->node_name ? (uint8_t)strlen(ni->node_name) : 0;
    msg.local_v4_sockets = ni_list_count((struct _ni_head*)ni->v4_sock_meta);
    msg.local_v4_addrs   = ni_list_count((struct _ni_head*)ni->v4_addrs);
    msg.local_v6_sockets = ni_list_count((struct _ni_head*)ni->v6_sock_meta);
    msg.local_v6_addrs   = ni_list_count((struct _ni_head*)ni->v6_addrs);
    msg.local_v4_subnets = nq->routes ? ni_list_count((struct _ni_head*)nq->routes->v4_subnets) : 0;
    msg.local_v6_subnets = nq->routes ? ni_list_count((struct _ni_head*)nq->routes->v6_subnets) : 0;
    msg.tranzit_nodes    = nq->tranzit_count;
    msg.hop_count        = nq->hop_count;

    size_t total = NODEINFO_MSG_HDR_SIZE + (size_t)nodeinfo_dyn_size(&msg);
    if (total > out_max) return -1;

    memcpy(out, &msg, NODEINFO_MSG_HDR_SIZE);
    uint8_t* dp = out + NODEINFO_MSG_HDR_SIZE;

    if (msg.node_name_len) { memcpy(dp, ni->node_name, msg.node_name_len); dp += msg.node_name_len; }

    { struct NI_IPV4_SOCKET_META* e = ni->v4_sock_meta; while (e) {
        struct NODEINFO_IPV4_SOCKET_META w = { .id=e->id, .config_type=e->config_type, .nat_type=e->nat_type };
        memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
    }}
    { struct NI_IPV4_ADDR* e = ni->v4_addrs; while (e) {
        struct NODEINFO_IPV4_ADDR w = { .port=e->port, .type=e->type, .socket_id=e->socket_id, .protocol=e->protocol };
        memcpy(w.addr, e->addr, 4); memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
    }}
    { struct NI_IPV6_SOCKET_META* e = ni->v6_sock_meta; while (e) {
        struct NODEINFO_IPV6_SOCKET_META w = { .id=e->id, .config_type=e->config_type, .nat_type=e->nat_type };
        memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
    }}
    { struct NI_IPV6_ADDR* e = ni->v6_addrs; while (e) {
        struct NODEINFO_IPV6_ADDR w = { .port=e->port, .type=e->type, .socket_id=e->socket_id, .protocol=e->protocol };
        memcpy(w.addr, e->addr, 16); memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
    }}
    if (msg.flags & NODEINFO_FLAG_SEND_SUBNETS) {
        if (nq->routes) {
            { struct NI_IPV4_SUBNET* e = nq->routes->v4_subnets; while (e) {
                struct NODEINFO_IPV4_SUBNET w = { .prefix_length=e->prefix_length };
                memcpy(w.addr, e->addr, 4); memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
            }}
            { struct NI_IPV6_SUBNET* e = nq->routes->v6_subnets; while (e) {
                struct NODEINFO_IPV6_SUBNET w = { .prefix_length=e->prefix_length };
                memcpy(w.addr, e->addr, 16); memcpy(dp, &w, sizeof(w)); dp += sizeof(w); e = e->next;
            }}
        }
    }
    if (msg.tranzit_nodes && nq->tranzit_data) {
        size_t sz = msg.tranzit_nodes * sizeof(struct NODEINFO_TRANZIT_NODE);
        memcpy(dp, nq->tranzit_data, sz); dp += sz;
    }
    if (msg.hop_count && nq->hop_list) {
        size_t sz = msg.hop_count * 8;
        memcpy(dp, nq->hop_list, sz); dp += sz;
    }
    return (int)(dp - out);
}

// ===== deserialization =====

int nodeinfo_deserialize(struct ROUTE_BGP* bgp, const uint8_t* data, size_t len, struct NODEINFO** out_ni, struct NODEINFO_ROUTES** out_routes,
                         struct NODEINFO_TRANZIT_NODE** out_tranzit, uint8_t* out_tranzit_count,
                         uint64_t** out_hop_list, uint8_t* out_hop_count) {
    if (!bgp || !data || len < NODEINFO_MSG_HDR_SIZE || !out_ni) return -1;

    const struct NODEINFO_MSG* msg = (const struct NODEINFO_MSG*)data;
    int dyn = nodeinfo_dyn_size(msg);
    if ((size_t)dyn + NODEINFO_MSG_HDR_SIZE != len) return -1;

    struct NODEINFO* ni = u_calloc(1, sizeof(struct NODEINFO));
    if (!ni) { DEBUG_ERROR(DEBUG_CATEGORY_BGP, "nodeinfo_deserialize: alloc NODEINFO failed"); return -1; }
    ni->ref_count = 1;
    ni->flags     = msg->flags;
    ni->group_id  = msg->group_id;
    ni->node_id   = msg->node_id;
    ni->ver       = msg->ver;
    memcpy(ni->public_key, msg->public_key, SC_PUBKEY_SIZE);
    memcpy(ni->ed25519_public_key, msg->ed25519_public_key, SC_PUBKEY_SIZE);

    const uint8_t* dp = data + NODEINFO_MSG_HDR_SIZE;

    if (msg->node_name_len) {
        ni->node_name = u_malloc(msg->node_name_len + 1);
        if (ni->node_name) { memcpy(ni->node_name, dp, msg->node_name_len); ni->node_name[msg->node_name_len] = 0; }
        dp += msg->node_name_len;
    }

    for (int i = 0; i < msg->local_v4_sockets; i++) {
        const struct NODEINFO_IPV4_SOCKET_META* w = (const struct NODEINFO_IPV4_SOCKET_META*)dp; dp += sizeof(*w);
        struct NI_IPV4_SOCKET_META* e = memory_pool_alloc(bgp->v4_sock_meta_pool);
        if (!e) { nodeinfo_unref(ni); return -1; }
        e->id = w->id; e->config_type = w->config_type; e->nat_type = w->nat_type;
        e->next = ni->v4_sock_meta; ni->v4_sock_meta = e;
    }
    for (int i = 0; i < msg->local_v4_addrs; i++) {
        const struct NODEINFO_IPV4_ADDR* w = (const struct NODEINFO_IPV4_ADDR*)dp; dp += sizeof(*w);
        struct NI_IPV4_ADDR* e = memory_pool_alloc(bgp->v4_addr_pool);
        if (!e) { nodeinfo_unref(ni); return -1; }
        memcpy(e->addr, w->addr, 4); e->port = w->port; e->type = w->type; e->socket_id = w->socket_id; e->protocol = w->protocol;
        e->next = ni->v4_addrs; ni->v4_addrs = e;
    }
    for (int i = 0; i < msg->local_v6_sockets; i++) {
        const struct NODEINFO_IPV6_SOCKET_META* w = (const struct NODEINFO_IPV6_SOCKET_META*)dp; dp += sizeof(*w);
        struct NI_IPV6_SOCKET_META* e = memory_pool_alloc(bgp->v6_sock_meta_pool);
        if (!e) { nodeinfo_unref(ni); return -1; }
        e->id = w->id; e->config_type = w->config_type; e->nat_type = w->nat_type;
        e->next = ni->v6_sock_meta; ni->v6_sock_meta = e;
    }
    for (int i = 0; i < msg->local_v6_addrs; i++) {
        const struct NODEINFO_IPV6_ADDR* w = (const struct NODEINFO_IPV6_ADDR*)dp; dp += sizeof(*w);
        struct NI_IPV6_ADDR* e = memory_pool_alloc(bgp->v6_addr_pool);
        if (!e) { nodeinfo_unref(ni); return -1; }
        memcpy(e->addr, w->addr, 16); e->port = w->port; e->type = w->type; e->socket_id = w->socket_id; e->protocol = w->protocol;
        e->next = ni->v6_addrs; ni->v6_addrs = e;
    }

    if (out_routes && (msg->flags & NODEINFO_FLAG_SEND_SUBNETS) && (msg->local_v4_subnets || msg->local_v6_subnets)) {
        struct NODEINFO_ROUTES* r = u_calloc(1, sizeof(struct NODEINFO_ROUTES));
        if (!r) { nodeinfo_unref(ni); return -1; }
        for (int i = 0; i < msg->local_v4_subnets; i++) {
            const struct NODEINFO_IPV4_SUBNET* w = (const struct NODEINFO_IPV4_SUBNET*)dp; dp += sizeof(*w);
            struct NI_IPV4_SUBNET* e = memory_pool_alloc(bgp->v4_subnet_pool);
            if (!e) { u_free(r); nodeinfo_unref(ni); return -1; }
            memcpy(e->addr, w->addr, 4); e->prefix_length = w->prefix_length;
            e->next = r->v4_subnets; r->v4_subnets = e;
        }
        for (int i = 0; i < msg->local_v6_subnets; i++) {
            const struct NODEINFO_IPV6_SUBNET* w = (const struct NODEINFO_IPV6_SUBNET*)dp; dp += sizeof(*w);
            struct NI_IPV6_SUBNET* e = memory_pool_alloc(bgp->v6_subnet_pool);
            if (!e) { u_free(r); nodeinfo_unref(ni); return -1; }
            memcpy(e->addr, w->addr, 16); e->prefix_length = w->prefix_length;
            e->next = r->v6_subnets; r->v6_subnets = e;
        }
        *out_routes = r;
    } else if (!(msg->flags & NODEINFO_FLAG_SEND_SUBNETS)) {
        dp += msg->local_v4_subnets * sizeof(struct NODEINFO_IPV4_SUBNET)
            + msg->local_v6_subnets * sizeof(struct NODEINFO_IPV6_SUBNET);
        if (out_routes) *out_routes = NULL;
    } else {
        if (out_routes) *out_routes = NULL;
    }

    if (out_tranzit && msg->tranzit_nodes > 0) {
        size_t tsz = msg->tranzit_nodes * sizeof(struct NODEINFO_TRANZIT_NODE);
        *out_tranzit = u_malloc(tsz);
        if (!*out_tranzit) { nodeinfo_unref(ni); return -1; }
        memcpy(*out_tranzit, dp, tsz); dp += tsz;
        *out_tranzit_count = msg->tranzit_nodes;
    }
    if (out_hop_list && msg->hop_count > 0) {
        size_t hsz = msg->hop_count * 8;
        *out_hop_list = u_malloc(hsz);
        if (!*out_hop_list) { nodeinfo_unref(ni); return -1; }
        memcpy(*out_hop_list, dp, hsz); dp += hsz;
        *out_hop_count = msg->hop_count;
    }

    *out_ni = ni;
    return 0;
}

struct NODEINFO_Q* nodeinfo_find_by_id(struct ROUTE_BGP* bgp, uint64_t node_id) {
    if (!bgp || !bgp->nodes) return NULL;
    uint64_t key = node_id;
    struct ll_entry* e = queue_find_data_by_index(bgp->nodes, &key);
    return e ? (struct NODEINFO_Q*)e : NULL;
}

// ===== dump / format (updated for new structures) =====

static int is_node_connectivity_active(struct NODE_CONNECTIVITY* c) {
    return c->probe_status != PROBE_STATUS_NONE
        || c->interface_status != PROBE_RESULT_UNKNOWN
        || c->nat_status != PROBE_RESULT_UNKNOWN
        || c->real_status != PROBE_RESULT_UNKNOWN
        || c->probe_start_time != 0
        || c->ping_req_time != 0;
}

static const char* probe_status_str(uint8_t s) {
    switch (s) { case 0: return "NONE"; case 1: return "IN_PROGRESS"; case 2: return "DONE"; default: return "?"; }
}
static const char* probe_result_str(uint8_t s) {
    switch (s) { case 0: return "UNKNOWN"; case 1: return "REACHABLE"; case 2: return "UNREACHABLE"; default: return "?"; }
}
static const char* conn_mgr_type_str(uint8_t t) {
    switch (t) { case 1: return "DIRECT"; case 2: return "REVERSE"; case 3: return "INDIRECT"; default: return "NONE"; }
}

void route_node_dump_all(struct ROUTE_BGP* bgp) {
    if (!bgp || !bgp->nodes) return;

    DEBUG_INFO(DEBUG_CATEGORY_BGP, "=== BGP Nodes dump: %d nodes ===", queue_entry_count(bgp->nodes));

    int idx = 0;
    struct ll_entry* e = bgp->nodes->head;
    while (e) {
        struct NODEINFO_Q* nq = (struct NODEINFO_Q*)e;
        struct NODEINFO* ni = nq->node;
        if (!ni) { e = e->next; continue; }
        int is_local = (bgp->local_node == nq);
        const char* name_s = ni->node_name ? ni->node_name : "";

        DEBUG_INFO(DEBUG_CATEGORY_BGP, "--- Node #%d: id=%016llx name=\"%s\" ver=%u dirty=%u alien=%u grp=%llu%s ---",
                   idx, (unsigned long long)ni->node_id, name_s, ni->ver, nq->dirty, nq->alien,
                   (unsigned long long)ni->group_id, is_local ? " [LOCAL]" : "");

        if (nq->best_socket) DEBUG_INFO(DEBUG_CATEGORY_BGP, "  best_socket=%p", (void*)nq->best_socket);

        log_dump(DEBUG_LEVEL_INFO, DEBUG_CATEGORY_BGP, "  pubkey ", ni->public_key, SC_PUBKEY_SIZE);
        log_dump(DEBUG_LEVEL_INFO, DEBUG_CATEGORY_BGP, "  ed25519", ni->ed25519_public_key, SC_PUBKEY_SIZE);

        int si = 0;
        { struct NI_IPV4_SOCKET_META* sm = ni->v4_sock_meta; while (sm) {
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v4sock[%d]: id=%u config=%u nat=%u", si++, sm->id, sm->config_type, sm->nat_type);
            sm = sm->next;
        }}
        { const char* atn[] = {"INTERFACE","NAT","REAL"};
          int ai = 0; struct NI_IPV4_ADDR* a = ni->v4_addrs; while (a) {
            const char* proto = (a->protocol & NODE_PROTO_TCP) ? "tcp" : (a->protocol & NODE_PROTO_UDP) ? "udp" : "?";
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v4addr[%d]: %s:%u %s sock=%u proto=%s", ai++,
                       ip_to_str(a->addr, AF_INET).str, a->port, (a->type<=2)?atn[a->type]:"?", a->socket_id, proto);
            a = a->next;
        }}
        { int si6 = 0; struct NI_IPV6_SOCKET_META* sm6 = ni->v6_sock_meta; while (sm6) {
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v6sock[%d]: id=%u config=%u nat=%u", si6++, sm6->id, sm6->config_type, sm6->nat_type);
            sm6 = sm6->next;
        }}
        { int ai6 = 0; struct NI_IPV6_ADDR* a6 = ni->v6_addrs; while (a6) {
            const char* proto = (a6->protocol & NODE_PROTO_TCP) ? "tcp" : (a6->protocol & NODE_PROTO_UDP) ? "udp" : "?";
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v6addr[%d]: %s:%u type=%u sock=%u proto=%s", ai6++,
                       ip_to_str(a6->addr, AF_INET6).str, a6->port, a6->type, a6->socket_id, proto);
            a6 = a6->next;
        }}
        if (nq->routes) {
            { int ri = 0; struct NI_IPV4_SUBNET* sub = nq->routes->v4_subnets; while (sub) {
                DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v4sub[%d]: %s/%d", ri++, ip_to_str(sub->addr, AF_INET).str, sub->prefix_length);
                sub = sub->next;
            }}
            { int ri6 = 0; struct NI_IPV6_SUBNET* sub6 = nq->routes->v6_subnets; while (sub6) {
                DEBUG_INFO(DEBUG_CATEGORY_BGP, "  v6sub[%d]: %s/%d", ri6++, ip_to_str(sub6->addr, AF_INET6).str, sub6->prefix_length);
                sub6 = sub6->next;
            }}
        }
        for (int i = 0; i < nq->tranzit_count; i++) {
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  tranzit[%d]: node=%016llx rtt=%u linkq=%u",
                       i, (unsigned long long)nq->tranzit_data[i].node_id, nq->tranzit_data[i].rtt, nq->tranzit_data[i].link_q);
        }

        int path_idx = 0;
        if (nq->paths) {
            struct ll_entry* pe = nq->paths->head;
            while (pe) {
                struct NODEINFO_PATH* path = (struct NODEINFO_PATH*)pe;
                uint64_t* hop = (uint64_t*)((uint8_t*)path + sizeof(struct NODEINFO_PATH));
                char hop_buf[256] = ""; int hop_pos = 0;
                for (uint8_t hi = 0; hi < path->hop_count && hop_pos < (int)sizeof(hop_buf)-20; hi++)
                    hop_pos += snprintf(hop_buf + hop_pos, sizeof(hop_buf) - hop_pos, "%s%016llx", hi ? "->" : "", (unsigned long long)hop[hi]);
                DEBUG_INFO(DEBUG_CATEGORY_BGP, "  path[%d]: conn=%s hop_count=%u hops=[%s]",
                           path_idx, path->conn ? path->conn->log_name : "NULL", path->hop_count, hop_buf);
                path_idx++; pe = pe->next;
            }
        }

        struct NODE_CONNECTIVITY* c = &nq->connectivity;
        if (is_node_connectivity_active(c)) {
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  connectivity: probe=%s iface=%s(%u) nat=%s(%u) real=%s(%u) pend=%u iface_rtt=%u nat_rtt=%u real_rtt=%u start_tb=%llu ping_req_tb=%llu",
                       probe_status_str(c->probe_status), probe_result_str(c->interface_status), c->interface_min_rtt,
                       probe_result_str(c->nat_status), c->nat_min_rtt, probe_result_str(c->real_status), c->real_min_rtt,
                       c->pending_count, c->interface_min_rtt, c->nat_min_rtt, c->real_min_rtt,
                       (unsigned long long)c->probe_start_time, (unsigned long long)c->ping_req_time);
        }
        if (nq->conn_mgr_type != CONN_TYPE_NONE) {
            char interm_buf[200] = ""; int ipos = 0;
            for (uint8_t i = 0; i < nq->conn_mgr_intermediariy_count && ipos < (int)sizeof(interm_buf)-19; i++)
                ipos += snprintf(interm_buf + ipos, sizeof(interm_buf) - ipos, "%s%016llx", i ? "," : "", (unsigned long long)nq->conn_mgr_intermediaries[i]);
            DEBUG_INFO(DEBUG_CATEGORY_BGP, "  conn_mgr: type=%s intermediates=[%s]", conn_mgr_type_str(nq->conn_mgr_type), interm_buf);
        }

        e = e->next; idx++;
    }
}

int route_node_format_all(struct ROUTE_BGP* bgp, char* buf, size_t buf_size) {
    if (!bgp || !bgp->nodes || !buf || buf_size == 0) return 0;
    int pos = 0;

    pos += snprintf(buf + pos, buf_size > (size_t)pos ? buf_size - pos : 0,
                    "=== BGP Nodes dump: %d nodes ===\n", queue_entry_count(bgp->nodes));

    int idx = 0;
    struct ll_entry* e = bgp->nodes->head;
    while (e && (size_t)pos < buf_size) {
        struct NODEINFO_Q* nq = (struct NODEINFO_Q*)e;
        struct NODEINFO* ni = nq->node;
        if (!ni) { e = e->next; continue; }
        int is_local = (bgp->local_node == nq);
        const char* name_s = ni->node_name ? ni->node_name : "";

#define FMT_ADD(fmt, ...) pos += snprintf(buf + pos, buf_size > (size_t)pos ? buf_size - pos : 0, fmt, ##__VA_ARGS__)

        FMT_ADD("--- Node #%d: id=%016llx name=\"%s\" ver=%u dirty=%u alien=%u grp=%llu%s ---\n",
                idx, (unsigned long long)ni->node_id, name_s, ni->ver, nq->dirty, nq->alien,
                (unsigned long long)ni->group_id, is_local ? " [LOCAL]" : "");

        if (nq->best_socket) FMT_ADD("  best_socket=%p\n", (void*)nq->best_socket);

        FMT_ADD("  pubkey: "); for (int k = 0; k < SC_PUBKEY_SIZE; k++) FMT_ADD("%02x", ni->public_key[k]); FMT_ADD("\n");
        FMT_ADD("  ed25519: "); for (int k = 0; k < SC_PUBKEY_SIZE; k++) FMT_ADD("%02x", ni->ed25519_public_key[k]); FMT_ADD("\n");

        { struct NI_IPV4_SOCKET_META* sm = ni->v4_sock_meta; int si = 0; while (sm) {
            FMT_ADD("  v4sock[%d]: id=%u config=%u nat=%u\n", si++, sm->id, sm->config_type, sm->nat_type); sm = sm->next;
        }}
        { const char* atn[] = {"INTERFACE","NAT","REAL"}; struct NI_IPV4_ADDR* a = ni->v4_addrs; int ai = 0; while (a) {
            const char* proto = (a->protocol & NODE_PROTO_TCP) ? "tcp" : (a->protocol & NODE_PROTO_UDP) ? "udp" : "?";
            FMT_ADD("  v4addr[%d]: %s:%u %s sock=%u proto=%s\n",
                    ai++, ip_to_str(a->addr, AF_INET).str, a->port, (a->type<=2)?atn[a->type]:"?", a->socket_id, proto);
            a = a->next;
        }}
        { struct NI_IPV6_SOCKET_META* sm6 = ni->v6_sock_meta; int s6i = 0; while (sm6) {
            FMT_ADD("  v6sock[%d]: id=%u config=%u nat=%u\n", s6i++, sm6->id, sm6->config_type, sm6->nat_type); sm6 = sm6->next;
        }}
        { struct NI_IPV6_ADDR* a6 = ni->v6_addrs; int a6i = 0; while (a6) {
            const char* proto = (a6->protocol & NODE_PROTO_TCP) ? "tcp" : (a6->protocol & NODE_PROTO_UDP) ? "udp" : "?";
            FMT_ADD("  v6addr[%d]: %s:%u type=%u sock=%u proto=%s\n",
                    a6i++, ip_to_str(a6->addr, AF_INET6).str, a6->port, a6->type, a6->socket_id, proto);
            a6 = a6->next;
        }}
        if (nq->routes) {
            { struct NI_IPV4_SUBNET* sub = nq->routes->v4_subnets; int ri = 0; while (sub) {
                FMT_ADD("  v4sub[%d]: %s/%d\n", ri++, ip_to_str(sub->addr, AF_INET).str, sub->prefix_length); sub = sub->next;
            }}
            { struct NI_IPV6_SUBNET* sub6 = nq->routes->v6_subnets; int r6i = 0; while (sub6) {
                FMT_ADD("  v6sub[%d]: %s/%d\n", r6i++, ip_to_str(sub6->addr, AF_INET6).str, sub6->prefix_length); sub6 = sub6->next;
            }}
        }
        for (int i = 0; i < nq->tranzit_count; i++)
            FMT_ADD("  tranzit[%d]: node=%016llx rtt=%u linkq=%u\n",
                    i, (unsigned long long)nq->tranzit_data[i].node_id, nq->tranzit_data[i].rtt, nq->tranzit_data[i].link_q);

        if (nq->paths) {
            struct ll_entry* pe = nq->paths->head; int pi = 0;
            while (pe) {
                struct NODEINFO_PATH* path = (struct NODEINFO_PATH*)pe;
                uint64_t* hop = (uint64_t*)((uint8_t*)path + sizeof(struct NODEINFO_PATH));
                FMT_ADD("  path[%d]: conn=%s hop_count=%u hops=[", pi++, path->conn ? path->conn->log_name : "NULL", path->hop_count);
                for (uint8_t hi = 0; hi < path->hop_count; hi++)
                    FMT_ADD("%s%016llx", hi ? "->" : "", (unsigned long long)hop[hi]);
                FMT_ADD("]\n"); pe = pe->next;
            }
        }

        struct NODE_CONNECTIVITY* c = &nq->connectivity;
        if (is_node_connectivity_active(c)) {
            FMT_ADD("  connectivity: probe=%s iface=%s(%u) nat=%s(%u) real=%s(%u) pend=%u iface_rtt=%u nat_rtt=%u real_rtt=%u start_tb=%llu ping_req_tb=%llu\n",
                    probe_status_str(c->probe_status), probe_result_str(c->interface_status), c->interface_min_rtt,
                    probe_result_str(c->nat_status), c->nat_min_rtt, probe_result_str(c->real_status), c->real_min_rtt,
                    c->pending_count, c->interface_min_rtt, c->nat_min_rtt, c->real_min_rtt,
                    (unsigned long long)c->probe_start_time, (unsigned long long)c->ping_req_time);
        }
        if (nq->conn_mgr_type != CONN_TYPE_NONE) {
            FMT_ADD("  conn_mgr: type=%s intermediates=[", conn_mgr_type_str(nq->conn_mgr_type));
            for (uint8_t i = 0; i < nq->conn_mgr_intermediariy_count; i++)
                FMT_ADD("%s%016llx", i ? "," : "", (unsigned long long)nq->conn_mgr_intermediaries[i]);
            FMT_ADD("]\n");
        }

#undef FMT_ADD
        e = e->next; idx++;
    }

    if ((size_t)pos >= buf_size) {
        pos = (int)buf_size - 14; if (pos < 0) pos = 0;
        pos += snprintf(buf + pos, buf_size - pos, "\n[TRUNCATED]\n");
    }
    return pos;
}

// ===== update my nodeinfo (rewritten for new structures) =====

int route_bgp_update_my_nodeinfo(struct UTUN_INSTANCE* instance, struct ROUTE_BGP* bgp) {
    if (!instance || !bgp) { DEBUG_ERROR(DEBUG_CATEGORY_BGP, "route_bgp_update_my_nodeinfo: invalid args"); return -1; }
    size_t name_len = 0;
    if (instance->name[0]) { name_len = strlen(instance->name); if (name_len > 63) name_len = 63; }
    int vc = 0, vc6 = 0;
    struct CFG_ROUTE_ENTRY* s = instance->config->my_subnets;
    while (s) { if (s->ip.family == AF_INET) vc++; else if (s->ip.family == AF_INET6) vc6++; s = s->next; }

    int sock_count = 0, addr_count = 0, sock6_count = 0, addr6_count = 0;
    struct ETCP_SOCKET* e_sock = instance->etcp_sockets;
    while (e_sock) {
        if (e_sock->type == CFG_SERVER_TYPE_PRIVATE || e_sock->type == CFG_SERVER_TYPE_LOCAL) { e_sock = e_sock->next; continue; }
        if (e_sock->local_addr.ss_family == AF_INET) {
            sock_count++; addr_count++;
            if (e_sock->nat_addr.ss_family == AF_INET) {
                struct sockaddr_in* nat_sin = (struct sockaddr_in*)&e_sock->nat_addr;
                if (nat_sin->sin_addr.s_addr != 0 && e_sock->nat_type != NAT_VERIFIED_STRICT) addr_count++;
            }
            if (e_sock->nat_type == NAT_VERIFIED_DIRECT || ((e_sock->type == CFG_SERVER_TYPE_PUBLIC || e_sock->type == CFG_SERVER_TYPE_UNKNOWN) && e_sock->nat_type < NAT_VERIFIED_UNKNOWN)) addr_count++;
        } else if (e_sock->local_addr.ss_family == AF_INET6) { sock6_count++; addr6_count++; }
        e_sock = e_sock->next;
    }
    { struct CFG_SERVER* srv = instance->config->servers;
      while (srv) { if (srv->transport) { if (srv->ip.ss_family == AF_INET) addr_count++; else if (srv->ip.ss_family == AF_INET6) addr6_count++; } srv = srv->next; }
    }

    int changed = 1; uint8_t old_ver = 0;
    if (bgp->local_node && bgp->local_node->node) {
        struct NODEINFO* oni = bgp->local_node->node;
        old_ver = oni->ver;
        int v4a_cnt = ni_list_count((struct _ni_head*)oni->v4_addrs);
        changed = (vc != (bgp->local_node->routes ? ni_list_count((struct _ni_head*)bgp->local_node->routes->v4_subnets) : 0))
               || (sock_count != ni_list_count((struct _ni_head*)oni->v4_sock_meta))
               || (addr_count != v4a_cnt)
               || (name_len != (oni->node_name ? strlen(oni->node_name) : 0))
               || (memcmp(oni->public_key, instance->my_keys.public_key, SC_PUBKEY_SIZE) != 0)
               || (vc6 != (bgp->local_node->routes ? ni_list_count((struct _ni_head*)bgp->local_node->routes->v6_subnets) : 0))
               || (sock6_count != ni_list_count((struct _ni_head*)oni->v6_sock_meta))
               || (addr6_count != ni_list_count((struct _ni_head*)oni->v6_addrs));
        if (bgp->local_node && bgp->instance && bgp->instance->bgp)
            if (memcmp(oni->ed25519_public_key, bgp->instance->bgp->ed25519_public_key, SC_PUBKEY_SIZE) != 0) changed = 1;
    }

    if (changed) {
        if (bgp->local_node) {
            if (instance->rt) route_delete(instance->rt, bgp->local_node);
            nodeinfo_free_lists(bgp, bgp->local_node);
            u_free(bgp->local_node);
            bgp->local_node = NULL;
        }

        bgp->local_node = u_calloc(1, sizeof(struct NODEINFO_Q));
        if (!bgp->local_node) return -1;
        struct NODEINFO_Q* lq = bgp->local_node;

        struct NODEINFO* ni = u_calloc(1, sizeof(struct NODEINFO));
        if (!ni) { u_free(lq); bgp->local_node = NULL; return -1; }
        ni->ref_count = 1;
        ni->flags     = NODEINFO_FLAG_SEND_SUBNETS;
        ni->group_id  = NODEINFO_GROUP_UTUN;
        ni->node_id   = instance->node_id;
        ni->ver       = (old_ver % 255) + 1;
        memcpy(ni->public_key, instance->my_keys.public_key, SC_PUBKEY_SIZE);
        memcpy(ni->ed25519_public_key, bgp->ed25519_public_key, SC_PUBKEY_SIZE);
        if (name_len) { ni->node_name = u_malloc(name_len + 1); if (ni->node_name) { memcpy(ni->node_name, instance->name, name_len); ni->node_name[name_len] = 0; } }

        lq->node = ni;
        lq->hash_node_id = ni->node_id;
        lq->hop_count = 0;
        lq->dirty = 1;
        lq->last_ver = ni->ver;

        e_sock = instance->etcp_sockets;
        while (e_sock) {
            if (e_sock->type == CFG_SERVER_TYPE_PRIVATE || e_sock->type == CFG_SERVER_TYPE_LOCAL) { e_sock = e_sock->next; continue; }
            if (e_sock->local_addr.ss_family == AF_INET) {
                { struct NI_IPV4_SOCKET_META* sm = memory_pool_alloc(bgp->v4_sock_meta_pool);
                  sm->id = e_sock->sock_id; sm->config_type = e_sock->type; sm->nat_type = e_sock->nat_type;
                  sm->next = ni->v4_sock_meta; ni->v4_sock_meta = sm; }

                struct sockaddr_in* if_sin = (struct sockaddr_in*)&e_sock->interface_addr;
                struct sockaddr_in* nat_sin = (struct sockaddr_in*)&e_sock->nat_addr;

                { struct NI_IPV4_ADDR* a = memory_pool_alloc(bgp->v4_addr_pool);
                  memcpy(a->addr, &if_sin->sin_addr.s_addr, 4); a->port = ntohs(if_sin->sin_port);
                  a->type = ADDR_TYPE_INTERFACE; a->socket_id = e_sock->sock_id; a->protocol = NODE_PROTO_UDP;
                  a->next = ni->v4_addrs; ni->v4_addrs = a; }
                if (e_sock->nat_addr.ss_family == AF_INET && nat_sin->sin_addr.s_addr != 0 && e_sock->nat_type != NAT_VERIFIED_STRICT) {
                    struct NI_IPV4_ADDR* a = memory_pool_alloc(bgp->v4_addr_pool);
                    memcpy(a->addr, &nat_sin->sin_addr.s_addr, 4); a->port = ntohs(nat_sin->sin_port);
                    a->type = ADDR_TYPE_NAT; a->socket_id = e_sock->sock_id; a->protocol = NODE_PROTO_UDP;
                    a->next = ni->v4_addrs; ni->v4_addrs = a;
                }
                if (e_sock->nat_type == NAT_VERIFIED_DIRECT || ((e_sock->type == CFG_SERVER_TYPE_PUBLIC || e_sock->type == CFG_SERVER_TYPE_UNKNOWN) && e_sock->nat_type < NAT_VERIFIED_UNKNOWN)) {
                    struct NI_IPV4_ADDR* a = memory_pool_alloc(bgp->v4_addr_pool);
                    memcpy(a->addr, &if_sin->sin_addr.s_addr, 4); a->port = ntohs(if_sin->sin_port);
                    a->type = ADDR_TYPE_REAL; a->socket_id = e_sock->sock_id; a->protocol = NODE_PROTO_UDP;
                    a->next = ni->v4_addrs; ni->v4_addrs = a;
                }
            } else if (e_sock->local_addr.ss_family == AF_INET6) {
                { struct NI_IPV6_SOCKET_META* sm6 = memory_pool_alloc(bgp->v6_sock_meta_pool);
                  sm6->id = e_sock->sock_id; sm6->config_type = e_sock->type; sm6->nat_type = e_sock->nat_type;
                  sm6->next = ni->v6_sock_meta; ni->v6_sock_meta = sm6; }
                struct sockaddr_in6* if_sin6 = (struct sockaddr_in6*)&e_sock->interface_addr;
                { struct NI_IPV6_ADDR* a6 = memory_pool_alloc(bgp->v6_addr_pool);
                  memcpy(a6->addr, &if_sin6->sin6_addr, 16); a6->port = ntohs(if_sin6->sin6_port);
                  a6->type = ADDR_TYPE_INTERFACE; a6->socket_id = e_sock->sock_id; a6->protocol = NODE_PROTO_UDP;
                  a6->next = ni->v6_addrs; ni->v6_addrs = a6; }
            }
            e_sock = e_sock->next;
        }
        { struct CFG_SERVER* srv = instance->config->servers;
          while (srv) { if (srv->transport && srv->ip.ss_family == AF_INET) {
              struct sockaddr_in* tcp_sin = (struct sockaddr_in*)&srv->ip;
              struct NI_IPV4_ADDR* a = memory_pool_alloc(bgp->v4_addr_pool);
              memcpy(a->addr, &tcp_sin->sin_addr.s_addr, 4); a->port = ntohs(tcp_sin->sin_port);
              a->type = ADDR_TYPE_INTERFACE; a->socket_id = 0; a->protocol = NODE_PROTO_TCP;
              a->next = ni->v4_addrs; ni->v4_addrs = a;
          } else if (srv->transport && srv->ip.ss_family == AF_INET6) {
              struct sockaddr_in6* tcp_sin6 = (struct sockaddr_in6*)&srv->ip;
              struct NI_IPV6_ADDR* a6 = memory_pool_alloc(bgp->v6_addr_pool);
              memcpy(a6->addr, &tcp_sin6->sin6_addr, 16); a6->port = ntohs(tcp_sin6->sin6_port);
              a6->type = ADDR_TYPE_INTERFACE; a6->socket_id = 0; a6->protocol = NODE_PROTO_TCP;
              a6->next = ni->v6_addrs; ni->v6_addrs = a6;
          } srv = srv->next; }
        }

        if (vc || vc6) {
            struct NODEINFO_ROUTES* r = u_calloc(1, sizeof(struct NODEINFO_ROUTES));
            s = instance->config->my_subnets;
            while (s) {
                if (s->ip.family == AF_INET) {
                    struct NI_IPV4_SUBNET* sub = memory_pool_alloc(bgp->v4_subnet_pool);
                    memcpy(sub->addr, &s->ip.addr.v4, 4); sub->prefix_length = s->netmask;
                    sub->next = r->v4_subnets; r->v4_subnets = sub;
                } else if (s->ip.family == AF_INET6) {
                    struct NI_IPV6_SUBNET* sub6 = memory_pool_alloc(bgp->v6_subnet_pool);
                    memcpy(sub6->addr, &s->ip.addr.v6, 16); sub6->prefix_length = s->netmask;
                    sub6->next = r->v6_subnets; r->v6_subnets = sub6;
                }
                s = s->next;
            }
            lq->routes = r;
        }

        DEBUG_INFO(DEBUG_CATEGORY_BGP, "my_nodeinfo updated: v4s=%d v4a=%d v6s=%d v6a=%d v4sub=%d v6sub=%d ver=%d",
                   sock_count, addr_count, sock6_count, addr6_count, vc, vc6, ni->ver);
        if (instance->rt && !route_insert(instance->rt, lq))
            DEBUG_WARN(DEBUG_CATEGORY_ROUTING, "route_bgp_update_my_nodeinfo: failed to insert local routes");
    } else {
        bgp->local_node->last_ver = bgp->local_node->node->ver;
    }
    return vc;
}