//
//  kwrite_counter.c
//  W0lfSword
//
//  BUG.5: the counters behind the engine's "kernel writes issued" summary. See
//  kwrite_counter.h for why counting at early_kwrite32bytes is counting every
//  write this chain can issue.
//
//  Deliberately dependency-free (stdint + stdatomic only) so the host test
//  (tests/kwrite_counter_host_test.c) compiles the same file the engine builds.
//
#include "kwrite_counter.h"

#include <stdatomic.h>

static _Atomic uint64_t g_writes[KWRITE_SRC_COUNT];
static _Atomic uint64_t g_bytes[KWRITE_SRC_COUNT];
static _Atomic uint64_t g_failed[KWRITE_SRC_COUNT];
static _Atomic uint64_t g_failedBytes[KWRITE_SRC_COUNT];

// Where the current thread's write comes from. Default KWRITE_SRC_KRW32: code
// that calls early_kwrite32bytes directly is that route by definition, and an
// un-attributed write must still be counted rather than dropped.
static _Thread_local kwrite_src_t t_src = KWRITE_SRC_KRW32;

static int src_valid(kwrite_src_t src)
{
    return src >= 0 && src < KWRITE_SRC_COUNT;
}

void kwrite_count_reset(void)
{
    for (int i = 0; i < KWRITE_SRC_COUNT; i++) {
        atomic_store_explicit(&g_writes[i], 0, __ATOMIC_RELAXED);
        atomic_store_explicit(&g_bytes[i], 0, __ATOMIC_RELAXED);
        atomic_store_explicit(&g_failed[i], 0, __ATOMIC_RELAXED);
        atomic_store_explicit(&g_failedBytes[i], 0, __ATOMIC_RELAXED);
    }
}

void kwrite_count_emit(kwrite_src_t src, uint32_t len)
{
    if (!src_valid(src)) src = KWRITE_SRC_KRW32;   // never lose a write
    atomic_fetch_add_explicit(&g_writes[src], 1, __ATOMIC_RELAXED);
    atomic_fetch_add_explicit(&g_bytes[src], (uint64_t)len, __ATOMIC_RELAXED);
}

void kwrite_count_failed(kwrite_src_t src, uint32_t len)
{
    if (!src_valid(src)) src = KWRITE_SRC_KRW32;
    atomic_fetch_add_explicit(&g_failed[src], 1, __ATOMIC_RELAXED);
    atomic_fetch_add_explicit(&g_failedBytes[src], (uint64_t)len, __ATOMIC_RELAXED);
}

uint64_t kwrite_count_total(void)
{
    uint64_t n = 0;
    for (int i = 0; i < KWRITE_SRC_COUNT; i++)
        n += atomic_load_explicit(&g_writes[i], __ATOMIC_RELAXED);
    return n;
}

uint64_t kwrite_count_bytes(void)
{
    uint64_t n = 0;
    for (int i = 0; i < KWRITE_SRC_COUNT; i++)
        n += atomic_load_explicit(&g_bytes[i], __ATOMIC_RELAXED);
    return n;
}

uint64_t kwrite_count_failed_total(void)
{
    uint64_t n = 0;
    for (int i = 0; i < KWRITE_SRC_COUNT; i++)
        n += atomic_load_explicit(&g_failed[i], __ATOMIC_RELAXED);
    return n;
}

uint64_t kwrite_count_failed_bytes(void)
{
    uint64_t n = 0;
    for (int i = 0; i < KWRITE_SRC_COUNT; i++)
        n += atomic_load_explicit(&g_failedBytes[i], __ATOMIC_RELAXED);
    return n;
}

uint64_t kwrite_count_for(kwrite_src_t src)
{
    if (!src_valid(src)) return 0;
    return atomic_load_explicit(&g_writes[src], __ATOMIC_RELAXED);
}

uint64_t kwrite_count_failed_for(kwrite_src_t src)
{
    if (!src_valid(src)) return 0;
    return atomic_load_explicit(&g_failed[src], __ATOMIC_RELAXED);
}

const char *kwrite_src_name(kwrite_src_t src)
{
    switch (src) {
    case KWRITE_SRC_KRW32: return "early_kwrite32bytes";
    case KWRITE_SRC_KRW64: return "early_kwrite64";
    case KWRITE_SRC_ZONE:  return "krw_zone_write_block";
    default:               return "unknown";
    }
}

kwrite_src_t kwrite_src_push(kwrite_src_t src)
{
    kwrite_src_t prev = t_src;
    if (src_valid(src)) t_src = src;
    return prev;
}

void kwrite_src_pop(kwrite_src_t prev)
{
    t_src = src_valid(prev) ? prev : KWRITE_SRC_KRW32;
}

kwrite_src_t kwrite_src_current(void)
{
    return t_src;
}
