/*
 * kido-ipi.c — Kido inter-processor interrupts.
 *
 * See kido-ipi.h for the discipline: module-global registry over
 * one SGI range, transport injected via ops, two types only,
 * send claims handoff never delivery, dispatch maps by
 * subtraction from base. This file is plain portable C — no
 * MMIO, no asm, no arch backend at all. The ARM64 proof that
 * remains is the SGI actually arriving on another CPU, which
 * needs the Gate wiring plus a QEMU virt -smp 2 run, stated
 * in the header, not implied here.
 *
 * TESTING: gcc -std=c11 -Wall -Wextra -Werror
 *        -DKIDO_HOSTED_TEST -DKIDO_IPI_SELFTEST
 *        kido-ipi.c -o ipi-selftest
 */
#include "kido-ipi.h"

/* ------------------------------------------------------------------ */
/* Registry: one IPI layer for one GIC (deliberation C1).             */
/* ------------------------------------------------------------------ */
static uint32_t g_ipi_magic = 0u;
static kido_ipi_ops_t g_ipi_ops;
static uint8_t g_ipi_base = 0u;
static kido_ipi_handler_t g_ipi_handlers[KIDO_IPI_TYPE_COUNT];
static void *g_ipi_args[KIDO_IPI_TYPE_COUNT];
static kido_ipi_stats_t g_ipi_stats;

static int kido_ipi_valid_type(kido_ipi_type_t type)
{
    return type >= KIDO_IPI_RESCHED && type < KIDO_IPI_TYPE_COUNT;
}

kido_status_t kido_ipi_init(const kido_ipi_ops_t *ops, uint8_t sgi_base)
{
    int i;
    if (ops == NULL || ops->send_sgi == NULL)
        return KIDO_ERR_EARLY_ENV;
    /* Two owned ids: base and base+1 must both fit SGI 0-15. */
    if (sgi_base > (uint8_t)(15u - (KIDO_IPI_TYPE_COUNT - 1u)))
        return KIDO_ERR_EARLY_ENV;
    /* Re-init rebuilds the world (deliberation C6): handlers,
     * args, and stats are cleared, the ops table is rebound. */
    g_ipi_ops = *ops;
    g_ipi_base = sgi_base;
    for (i = 0; i < KIDO_IPI_TYPE_COUNT; i++) {
        g_ipi_handlers[i] = NULL;
        g_ipi_args[i] = NULL;
        g_ipi_stats.sent[i] = 0u;
        g_ipi_stats.received[i] = 0u;
    }
    g_ipi_stats.unknown = 0u;
    g_ipi_magic = KIDO_IPI_MAGIC;
    return KIDO_OK;
}

kido_status_t kido_ipi_sgi_id(kido_ipi_type_t type, uint8_t *out)
{
    if (g_ipi_magic != KIDO_IPI_MAGIC || out == NULL)
        return KIDO_ERR_EARLY_ENV;
    if (!kido_ipi_valid_type(type))
        return KIDO_ERR_EARLY_ENV;
    *out = (uint8_t)(g_ipi_base + (uint8_t)type);
    return KIDO_OK;
}

kido_status_t kido_ipi_register_handler(kido_ipi_type_t type,
                                        kido_ipi_handler_t fn,
                                        void *arg)
{
    if (g_ipi_magic != KIDO_IPI_MAGIC)
        return KIDO_ERR_EARLY_ENV;
    if (!kido_ipi_valid_type(type))
        return KIDO_ERR_EARLY_ENV;
    /* fn == NULL unregisters (the GIC precedent). */
    g_ipi_handlers[type] = fn;
    g_ipi_args[type] = arg;
    return KIDO_OK;
}

kido_status_t kido_ipi_send(kido_ipi_type_t type, uint32_t cpu_mask)
{
    kido_status_t st;
    uint8_t narrow;
    if (g_ipi_magic != KIDO_IPI_MAGIC)
        return KIDO_ERR_EARLY_ENV;
    if (!kido_ipi_valid_type(type))
        return KIDO_ERR_EARLY_ENV;
    /* Mask law: zero routes nowhere; bits at or above the
     * 8-CPU census are refused, never silently truncated. */
    if (cpu_mask == 0u || cpu_mask >= (1u << KIDO_IPI_MAX_CPUS))
        return KIDO_ERR_EARLY_ENV;
    narrow = (uint8_t)cpu_mask; /* safe: validated above */
    st = g_ipi_ops.send_sgi(narrow, (uint8_t)(g_ipi_base + (uint8_t)type));
    if (st != KIDO_OK)
        return st; /* transport failure propagates, counts nothing */
    g_ipi_stats.sent[type]++;
    return KIDO_OK;
}

kido_status_t kido_ipi_dispatch(uint8_t sgi_id, uint32_t source_cpu)
{
    kido_ipi_type_t type;
    if (g_ipi_magic != KIDO_IPI_MAGIC)
        return KIDO_ERR_EARLY_ENV;
    /* Out-of-range arrival is a wiring bug made loud (C4):
     * the wiring registers dispatch for exactly the owned
     * ids, so anything else means it registered wrong. */
    if (sgi_id < g_ipi_base ||
        sgi_id >= (uint8_t)(g_ipi_base + KIDO_IPI_TYPE_COUNT)) {
        g_ipi_stats.unknown++;
        return KIDO_ERR_EARLY_ENV;
    }
    type = (kido_ipi_type_t)(sgi_id - g_ipi_base);
    g_ipi_stats.received[type]++;
    /* No handler is OK + counted (C5): a signal nobody
     * consumed yet is a fact, not an error. */
    if (g_ipi_handlers[type] != NULL)
        g_ipi_handlers[type](type, source_cpu, g_ipi_args[type]);
    return KIDO_OK;
}

kido_status_t kido_ipi_stats(kido_ipi_stats_t *out)
{
    if (g_ipi_magic != KIDO_IPI_MAGIC || out == NULL)
        return KIDO_ERR_EARLY_ENV;
    *out = g_ipi_stats;
    return KIDO_OK;
}

#ifdef KIDO_IPI_SELFTEST
#ifndef KIDO_HOSTED_TEST
#error "KIDO_IPI_SELFTEST needs KIDO_HOSTED_TEST."
#endif
#include <stdio.h>

#define IPI_CHECK(cond) do { \
    kido_ipi_checks++; \
    if (!(cond)) { \
        kido_ipi_failures++; \
        printf("[FAIL] line %d: %s\n", __LINE__, #cond); \
    } \
} while (0)

static int kido_ipi_checks = 0;
static int kido_ipi_failures = 0;

/* --- scripted transport: records every send, fails on demand. --- */
static uint8_t g_tx_mask = 0u;
static uint8_t g_tx_sgi = 0u;
static int g_tx_calls = 0;
static int g_tx_fail = 0;

static kido_status_t test_send_sgi(uint8_t cpu_mask, uint8_t sgi_id)
{
    g_tx_mask = cpu_mask;
    g_tx_sgi = sgi_id;
    g_tx_calls++;
    if (g_tx_fail)
        return KIDO_ERR_STUB_REACHED; /* distinct, proves propagation */
    return KIDO_OK;
}

/* --- recording handler: pins type, source, arg delivery. --- */
static kido_ipi_type_t g_rx_type = KIDO_IPI_TYPE_COUNT;
static uint32_t g_rx_source = 0u;
static void *g_rx_arg = NULL;
static int g_rx_calls = 0;

static void test_handler(kido_ipi_type_t type, uint32_t source_cpu,
                         void *arg)
{
    g_rx_type = type;
    g_rx_source = source_cpu;
    g_rx_arg = arg;
    g_rx_calls++;
}

int kido_ipi_selftest_main(void)
{
    kido_ipi_ops_t ops;
    kido_ipi_ops_t null_ops;
    kido_ipi_stats_t st;
    uint8_t id = 0u;
    int marker = 7;

    ops.send_sgi = test_send_sgi;
    null_ops.send_sgi = NULL;

    /* §0: before init, everything refuses loud. */
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x01u) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_dispatch(0u, 0u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_RESCHED, &id) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_register_handler(KIDO_IPI_RESCHED, test_handler,
                                        &marker) == KIDO_ERR_EARLY_ENV);

    /* §1: init guards, and refused inits leave it unbound. */
    IPI_CHECK(kido_ipi_init(NULL, 0u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_init(&null_ops, 0u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_init(&ops, 15u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_init(&ops, 255u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x01u) ==
              KIDO_ERR_EARLY_ENV);

    /* §2: init at the top of the range; the mapping is base+type. */
    IPI_CHECK(kido_ipi_init(&ops, 14u) == KIDO_OK);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_RESCHED, &id) == KIDO_OK &&
              id == 14u);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_PING, &id) == KIDO_OK &&
              id == 15u);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_TYPE_COUNT, &id) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_RESCHED, NULL) ==
              KIDO_ERR_EARLY_ENV);

    /* §3: register guards. */
    IPI_CHECK(kido_ipi_register_handler(KIDO_IPI_TYPE_COUNT,
                                        test_handler, &marker) ==
              KIDO_ERR_EARLY_ENV);

    /* §4: send guards — bad type, zero mask, bits past CPU 7. */
    IPI_CHECK(kido_ipi_send(KIDO_IPI_TYPE_COUNT, 0x01u) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0u) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x100u) ==
              KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x80000000u) ==
              KIDO_ERR_EARLY_ENV);

    /* §5: RESCHED to CPU 1 — handoff recorded, sent counted. */
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x02u) == KIDO_OK);
    IPI_CHECK(g_tx_calls == 1 && g_tx_mask == 0x02u && g_tx_sgi == 14u);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.sent[0] == 1u &&
              st.sent[1] == 0u);

    /* §6: transport failure propagates unchanged, counts nothing. */
    g_tx_fail = 1;
    IPI_CHECK(kido_ipi_send(KIDO_IPI_PING, 0x01u) ==
              KIDO_ERR_STUB_REACHED);
    IPI_CHECK(g_tx_calls == 2 && g_tx_mask == 0x01u && g_tx_sgi == 15u);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.sent[1] == 0u);
    g_tx_fail = 0;

    /* §7: out-of-range dispatch — unknown counted, refused loud. */
    IPI_CHECK(kido_ipi_dispatch(3u, 0u) == KIDO_ERR_EARLY_ENV);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.unknown == 1u);

    /* §8: dispatch with a handler — type, source, arg all land. */
    IPI_CHECK(kido_ipi_register_handler(KIDO_IPI_RESCHED, test_handler,
                                        &marker) == KIDO_OK);
    IPI_CHECK(kido_ipi_dispatch(14u, 3u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 1 && g_rx_type == KIDO_IPI_RESCHED &&
              g_rx_source == 3u && g_rx_arg == &marker);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[0] == 1u);

    /* §9: dispatch with no handler — OK, counted, no call. */
    IPI_CHECK(kido_ipi_dispatch(15u, 2u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 1);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[1] == 1u);

    /* §10: self-send path — mask 0x01, receipt from source 0. */
    IPI_CHECK(kido_ipi_send(KIDO_IPI_RESCHED, 0x01u) == KIDO_OK);
    IPI_CHECK(g_tx_mask == 0x01u && g_tx_sgi == 14u);
    IPI_CHECK(kido_ipi_dispatch(14u, 0u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 2 && g_rx_source == 0u);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[0] == 2u);

    /* §11: unregister — dispatch still OK + counted, no call. */
    IPI_CHECK(kido_ipi_register_handler(KIDO_IPI_RESCHED, NULL, NULL) ==
              KIDO_OK);
    IPI_CHECK(kido_ipi_dispatch(14u, 1u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 2);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[0] == 3u);

    /* §12: re-init rebuilds the world — new base, zeroed stats,
     * no handlers carried over. */
    IPI_CHECK(kido_ipi_init(&ops, 10u) == KIDO_OK);
    IPI_CHECK(kido_ipi_sgi_id(KIDO_IPI_RESCHED, &id) == KIDO_OK &&
              id == 10u);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.sent[0] == 0u &&
              st.sent[1] == 0u && st.received[0] == 0u &&
              st.received[1] == 0u && st.unknown == 0u);
    IPI_CHECK(kido_ipi_dispatch(10u, 0u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 2); /* old handler is gone */
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[0] == 1u);

    /* §13: register after re-init works on the new ids. */
    IPI_CHECK(kido_ipi_register_handler(KIDO_IPI_PING, test_handler,
                                        &marker) == KIDO_OK);
    IPI_CHECK(kido_ipi_dispatch(11u, 7u) == KIDO_OK);
    IPI_CHECK(g_rx_calls == 3 && g_rx_type == KIDO_IPI_PING &&
              g_rx_source == 7u && g_rx_arg == &marker);
    IPI_CHECK(kido_ipi_stats(&st) == KIDO_OK && st.received[1] == 1u);

    printf("[kido-ipi] %d checks, %d failures\n",
           kido_ipi_checks, kido_ipi_failures);
    return kido_ipi_failures;
}

int main(void)
{
    return kido_ipi_selftest_main() != 0;
}
#endif /* KIDO_IPI_SELFTEST */
