import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { int32atomic } from 'moroutine';

describe('Int32Atomic', () => {
  it('self-allocates and initializes to zero', () => {
    const a = int32atomic();
    assert.equal(a.load(), 0);
  });

  it('stores and loads a value', () => {
    const a = int32atomic();
    a.store(42);
    assert.equal(a.load(), 42);
  });

  it('exposes byteSize of 4', () => {
    assert.equal(int32atomic.byteSize, 4);
  });

  it('add returns previous value and updates', () => {
    const a = int32atomic();
    a.store(10);
    const prev = a.add(5);
    assert.equal(prev, 10);
    assert.equal(a.load(), 15);
  });

  it('sub returns previous value and updates', () => {
    const a = int32atomic();
    a.store(10);
    const prev = a.sub(3);
    assert.equal(prev, 10);
    assert.equal(a.load(), 7);
  });

  it('and returns previous value and updates', () => {
    const a = int32atomic();
    a.store(0b1100);
    const prev = a.and(0b1010);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b1000);
  });

  it('or returns previous value and updates', () => {
    const a = int32atomic();
    a.store(0b1100);
    const prev = a.or(0b0011);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b1111);
  });

  it('xor returns previous value and updates', () => {
    const a = int32atomic();
    a.store(0b1100);
    const prev = a.xor(0b1010);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b0110);
  });

  it('exchange returns previous value and sets new', () => {
    const a = int32atomic();
    a.store(42);
    const prev = a.exchange(99);
    assert.equal(prev, 42);
    assert.equal(a.load(), 99);
  });

  it('compareExchange succeeds when expected matches', () => {
    const a = int32atomic();
    a.store(42);
    const actual = a.compareExchange(42, 99);
    assert.equal(actual, 42);
    assert.equal(a.load(), 99);
  });

  it('compareExchange fails when expected does not match', () => {
    const a = int32atomic();
    a.store(42);
    const actual = a.compareExchange(0, 99);
    assert.equal(actual, 42);
    assert.equal(a.load(), 42);
  });

  it('waitAsync returns "not-equal" synchronously when value already differs', async () => {
    const a = int32atomic();
    a.store(5);
    const result = await a.waitAsync(0);
    assert.equal(result, 'not-equal');
  });

  it('waitAsync resolves "ok" when a concurrent store + notify happens', async () => {
    const a = int32atomic();
    const wait = a.waitAsync(0);
    setImmediate(() => {
      a.store(1);
      a.notify();
    });
    assert.equal(await wait, 'ok');
    assert.equal(a.load(), 1);
  });

  it('waitAsync resolves "timed-out" when no notify arrives', async () => {
    const a = int32atomic();
    const result = await a.waitAsync(0, 20);
    assert.equal(result, 'timed-out');
  });

  it('notify returns count of waiters woken', async () => {
    const a = int32atomic();
    const w1 = a.waitAsync(0);
    const w2 = a.waitAsync(0);
    const woken = a.notify();
    a.store(1);
    a.notify();
    assert.equal(woken + a.notify(), 2);
    await Promise.all([w1, w2]);
  });
});