// vtest build: !windows && (amd64 || arm64)
import sync
import time

struct Counter {
pub mut:
    i int
}

fn (mut c Counter) add(i int) {
    c.i = c.i + i
}

fn run(mut m sync.ManyTimes, mut co Counter, c chan bool) {
    m.do(fn [mut co] () {
        co.add(5)
    })
    c <- true
}

fn test_many_times_once() {
    mut co := &Counter{}
    mut m := sync.new_many_times(1)
    c := chan bool{}
    n := 10

    // It is executed 10 times, but only once actually.
    for i := 0; i < n; i++ {
        spawn run(mut m, mut co, c)
    }
    for i := 0; i < n; i++ {
        <-c
    }
    assert co.i == 5
}

fn test_many_times_fifth() {
    mut co := &Counter{}
    mut m := sync.new_many_times(5)
    c := chan bool{}
    n := 10

    // It is executed 10 times, but only 5 times actually.
    for i := 0; i < n; i++ {
        spawn run(mut m, mut co, c)
    }
    for i := 0; i < n; i++ {
        <-c
    }
    assert co.i == 25
}

// Ordering test: do must not return until f() has completed.
// The bug was that count was stored *before* f() ran, so a concurrent
// caller could observe count >= times and return on the fast path while
// f() was still executing.

struct ManyTimesState {
pub mut:
    value int
    ready chan bool
}

fn run_mt_ordering(mut m sync.ManyTimes, s &ManyTimesState, c chan bool) {
    m.do(fn [s] () {
        mut ms := unsafe { &ManyTimesState(s) }
        ms.ready <- true
        time.sleep(50 * time.millisecond)
        ms.value = 99
    })
    c <- true
}

fn test_many_times_ordering() {
    s := &ManyTimesState{
        ready: chan bool{cap: 1}
    }
    mut m := sync.new_many_times(1)
    c := chan bool{}

    spawn run_mt_ordering(mut m, s, c)

    // Wait until the goroutine is inside f().  With the old buggy code,
    // count is incremented before f() runs, so the second do() call sees
    // count >= times on the fast path and returns immediately — before
    // f() has finished.  With the fix, count is still 0 here, so the
    // second do() blocks on the mutex until f() completes.
    _ := <-s.ready
    m.do(fn () {})

    assert s.value == 99, 'do must not return before f() completes'
    _ := <-c
}