// vtest build: !true // goroutines module is experimental; skip on all CIs for now
// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module goroutines

import time

// Helper function for test_goroutine_create (must be a plain function, not a closure).
fn goroutine_test_worker(arg voidptr) {
	// Signal that the goroutine ran by writing to the shared flag
	if arg != unsafe { nil } {
		unsafe {
			mut flag := &bool(arg)
			*flag = true
		}
	}
}

// Test basic goroutine creation
fn test_goroutine_create() {
	mut done := false
	goroutine_create(voidptr(goroutine_test_worker), voidptr(&done), 0)
	// Give the goroutine time to run
	time.sleep(100 * time.millisecond)
}

// Test channel make
fn test_chan_make() {
	c := chan_make(int(sizeof(int)), 10)
	assert c != unsafe { nil }
	assert chan_cap(c) == 10
	assert chan_len(c) == 0
}

// Test buffered channel send/recv
fn test_chan_buffered() {
	c := chan_make(int(sizeof(int)), 5)
	mut val := 42
	assert chan_send(c, voidptr(&val), false) == true
	assert chan_len(c) == 1

	mut recv_val := 0
	received, ok := chan_recv(c, voidptr(&recv_val), false)
	assert received == true
	assert ok == true
	assert recv_val == 42
	assert chan_len(c) == 0
}

// Test channel close
fn test_chan_close() {
	c := chan_make(int(sizeof(int)), 1)
	mut val := 100
	chan_send(c, voidptr(&val), false)
	chan_close(c)

	// Should still receive buffered value
	mut recv_val := 0
	received, ok := chan_recv(c, voidptr(&recv_val), false)
	assert received == true
	// After close with data, ok should be true
}

// Test GoroutineQueue operations
fn test_gqueue() {
	mut q := GoroutineQueue{}
	assert q.empty()
	assert q.size == 0

	mut g1 := &Goroutine{
		id: 1
	}
	mut g2 := &Goroutine{
		id: 2
	}
	mut g3 := &Goroutine{
		id: 3
	}

	q.push_back(g1)
	assert !q.empty()
	assert q.size == 1

	q.push_back(g2)
	q.push_back(g3)
	assert q.size == 3

	gp := q.pop()
	assert gp.id == 1
	assert q.size == 2

	gp2 := q.pop()
	assert gp2.id == 2

	gp3 := q.pop()
	assert gp3.id == 3
	assert q.empty()
}

// Test GoroutineList operations
fn test_glist() {
	mut l := GoroutineList{}
	assert l.empty()

	mut g1 := &Goroutine{
		id: 10
	}
	mut g2 := &Goroutine{
		id: 20
	}

	l.push(g1)
	assert !l.empty()
	assert l.count == 1

	l.push(g2)
	assert l.count == 2

	// GoroutineList is a stack (LIFO)
	gp := l.pop()
	assert gp.id == 20

	gp2 := l.pop()
	assert gp2.id == 10
	assert l.empty()
}

// Test WaitQ operations
fn test_waitq() {
	mut q := WaitQ{}
	assert q.empty()

	mut g1 := &Goroutine{
		id: 1
	}
	mut g2 := &Goroutine{
		id: 2
	}

	mut s1 := &Sudog{
		g: g1
	}
	mut s2 := &Sudog{
		g: g2
	}

	q.enqueue(s1)
	assert !q.empty()

	q.enqueue(s2)

	sg := q.dequeue()
	assert sg.g.id == 1

	sg2 := q.dequeue()
	assert sg2.g.id == 2

	assert q.empty()
}

// Test scheduler initialization
fn test_scheduler_init() {
	// The scheduler should have been initialized by module init()
	assert gomaxprocs > 0
	assert gsched.allp.len > 0
	assert gsched.allp.len == int(gomaxprocs)

	// P0 should be running (attached to M0)
	p0 := gsched.allp[0]
	assert p0.status == .running
}

// Test goroutine ID allocation
fn test_goid_allocation() {
	id1 := assign_goid()
	id2 := assign_goid()
	// IDs should be unique and increasing
	assert id2 > id1
}