const std = @import("std");

const Io = std.Io;

var store_io: Io = undefined;
var initialized = false;
var mutex: Io.Mutex = .init;
var changed: Io.Condition = .init;
var generation: usize = 0;
var latest_seq: u64 = 0;

pub fn init(io: Io) void {
    store_io = io;
    initialized = true;
}

pub fn publish(seq: u64) void {
    if (!initialized) return;
    _ = @atomicRmw(usize, &generation, .Add, 1, .release);
    _ = @atomicRmw(u64, &latest_seq, .Max, seq, .release);
    changed.broadcast(store_io);
}

pub fn snapshot() Snapshot {
    return .{
        .generation = @atomicLoad(usize, &generation, .acquire),
        .latest_seq = @atomicLoad(u64, &latest_seq, .acquire),
    };
}

pub fn waitForChange(observed: usize) !Snapshot {
    try mutex.lock(store_io);
    defer mutex.unlock(store_io);

    while (@atomicLoad(usize, &generation, .acquire) == observed) {
        try changed.wait(store_io, &mutex);
    }
    return snapshot();
}

pub const Snapshot = struct {
    generation: usize,
    latest_seq: u64,
};