// observer_async_queue.c
// gcc -std=c11 -Wall -Wextra -O2 observer_async_queue.c -o demo && ./demo

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

/* =========================
 * 1) 事件定义：ID + payload(拷贝在事件里，避免指针悬挂)
 * ========================= */

typedef enum {
    EVT_A = 0,
    EVT_B,
    EVT_LOG,
    EVT_MAX
} event_id_t;

typedef struct {
    event_id_t id;
    union {
        int value;                 // EVT_A/EVT_B 用
        char msg[32];              // EVT_LOG 用
    } data;
} event_t;

/* =========================
 * 2) 观察者：回调
 * ========================= */
typedef void (*observer_cb_t)(const event_t *e, void *user);

typedef struct {
    observer_cb_t cb;
    void *user;
} observer_t;

/* =========================
 * 3) Subject / EventBus：每类事件一个订阅表（静态数组）
 * ========================= */
#define MAX_OBS 8

typedef struct {
    observer_t list[EVT_MAX][MAX_OBS];
    uint8_t    count[EVT_MAX];
} event_bus_t;

static void bus_init(event_bus_t *b)
{
    for (int i = 0; i < EVT_MAX; i++) b->count[i] = 0;
}

static int bus_subscribe(event_bus_t *b, event_id_t id, observer_cb_t cb, void *user)
{
    if (!b || !cb || id >= EVT_MAX) return -1;
    uint8_t n = b->count[id];
    if (n >= MAX_OBS) return -2;
    b->list[id][n].cb = cb;
    b->list[id][n].user = user;
    b->count[id] = (uint8_t)(n + 1);
    return 0;
}

static void bus_notify(event_bus_t *b, const event_t *e)
{
    if (!b || !e || e->id >= EVT_MAX) return;
    uint8_t n = b->count[e->id];
    for (uint8_t i = 0; i < n; i++) {
        observer_t *o = &b->list[e->id][i];
        o->cb(e, o->user);
    }
}

/* =========================
 * 4) 事件队列：环形缓冲区（异步派发核心）
 * ========================= */
#define QCAP 16

typedef struct {
    event_t  q[QCAP];
    uint8_t  head, tail, size;
    uint32_t dropped;     // 队列满导致丢事件计数（可观测性）
} event_queue_t;

static void q_init(event_queue_t *q)
{
    q->head = q->tail = q->size = 0;
    q->dropped = 0;
}

/* publish：只入队，不回调 */
static int q_push(event_queue_t *q, const event_t *e)
{
    if (!q || !e) return -1;
    if (q->size >= QCAP) {
        q->dropped++;
        return -2; // full
    }
    q->q[q->tail] = *e; // 事件整体拷贝，payload 不悬空
    q->tail = (uint8_t)((q->tail + 1) % QCAP);
    q->size++;
    return 0;
}

static int q_pop(event_queue_t *q, event_t *out)
{
    if (!q || !out) return -1;
    if (q->size == 0) return -2; // empty
    *out = q->q[q->head];
    q->head = (uint8_t)((q->head + 1) % QCAP);
    q->size--;
    return 0;
}

/* =========================
 * 5) 一个“调度器”：把队列里的事件取出来，通知观察者
 * ========================= */
static void dispatch_all(event_bus_t *bus, event_queue_t *q)
{
    event_t e;
    while (q_pop(q, &e) == 0) {
        bus_notify(bus, &e);
    }
}

/* =========================
 * 6) 观察者示例
 * ========================= */
static void obs_print(const event_t *e, void *user)
{
    const char *name = (const char*)user;
    if (e->id == EVT_LOG) {
        printf("[%s] LOG: %s\n", name, e->data.msg);
    } else {
        printf("[%s] EVT_%d value=%d\n", name, (int)e->id, e->data.value);
    }
}

typedef struct { int sum; } acc_t;

static void obs_acc(const event_t *e, void *user)
{
    acc_t *a = (acc_t*)user;
    if (e->id == EVT_A || e->id == EVT_B) {
        a->sum += e->data.value;
        printf("[ACC] sum=%d\n", a->sum);
    }
}

/* =========================
 * 7) “发布者”示例：模拟产生事件（只入队）
 * ========================= */
static void publish_A(event_queue_t *q, int v)
{
    event_t e = { .id = EVT_A };
    e.data.value = v;
    (void)q_push(q, &e);
}

static void publish_B(event_queue_t *q, int v)
{
    event_t e = { .id = EVT_B };
    e.data.value = v;
    (void)q_push(q, &e);
}

static void publish_LOG(event_queue_t *q, const char *msg)
{
    event_t e = { .id = EVT_LOG };
    snprintf(e.data.msg, sizeof(e.data.msg), "%s", msg);
    (void)q_push(q, &e);
}

/* =========================
 * 8) main：演示异步派发
 * ========================= */
int main(void)
{
    event_bus_t bus;
    event_queue_t q;
    bus_init(&bus);
    q_init(&q);

    acc_t acc = {0};

    /* 订阅：注意这时不会立刻收到事件，只有 dispatch 时才会收到 */
    bus_subscribe(&bus, EVT_A,  obs_print, (void*)"PRINT");
    bus_subscribe(&bus, EVT_B,  obs_print, (void*)"PRINT");
    bus_subscribe(&bus, EVT_LOG,obs_print, (void*)"PRINT");
    bus_subscribe(&bus, EVT_A,  obs_acc,   &acc);
    bus_subscribe(&bus, EVT_B,  obs_acc,   &acc);

    printf("=== Async Observer: publish only enqueues ===\n");

    /* “生产者”连续发布：此时不会打印，因为还没 dispatch */
    publish_A(&q, 10);
    publish_B(&q, 3);
    publish_LOG(&q, "hello (will print later)");
    publish_A(&q, 7);

    printf("\n(No output above from observers yet, because not dispatched)\n");

    /* 主循环某次 tick：统一派发 */
    printf("\n=== dispatch_all() ===\n");
    dispatch_all(&bus, &q);

    /* 再发布一波，模拟主循环多次 tick */
    printf("\n=== publish more, then dispatch again ===\n");
    publish_LOG(&q, "tick2 start");
    publish_B(&q, 100);
    publish_A(&q, -5);

    dispatch_all(&bus, &q);

    printf("\nQueue dropped=%u (if queue overflow happened)\n", (unsigned)q.dropped);
    return 0;
}