// 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.
//
// Goroutine runtime initialization.
// Translated from Go's schedinit() and procresize() in proc.go.
module goroutines

import runtime

// init initializes the goroutine scheduler.
// Creates P's (one per CPU core by default) and the initial M.
// Translated from Go's schedinit() + procresize().
fn init() {
	// Determine number of processors
	n := runtime.nr_cpus()
	if n < 1 {
		gomaxprocs = 1
	} else if n > 256 {
		gomaxprocs = 256
	} else {
		gomaxprocs = i32(n)
	}

	// Initialize the scheduler
	gsched.maxmcount = 10000
	gsched.mnext = 1

	// Create all P's (translated from procresize in proc.go)
	gsched.allp = []&Processor{cap: int(gomaxprocs)}
	for i in 0 .. gomaxprocs {
		mut pp := &Processor{
			id:     i
			status: .idle
		}
		// Initialize the local run queue
		for j in 0 .. local_queue_size {
			pp.runq[j] = unsafe { nil }
		}
		gsched.allp << pp
	}

	// Create the initial M (M0) for the main thread
	mut m0 := &Machine{
		id: 0
		g0: &Goroutine{
			id:     0
			status: .running
		}
	}

	// Create a "main goroutine" so chan_send/recv work from the main thread
	mut main_g := &Goroutine{
		id:     0
		status: .running
	}
	m0.curg = main_g
	main_g.m = m0

	// Wire M0 to P0
	mut p0 := gsched.allp[0]
	wire_p(mut m0, mut p0)

	// Set the current thread's M
	set_current_m(m0)

	// Put remaining P's on the idle list
	for i in 1 .. gomaxprocs {
		pid_put(gsched.allp[i])
	}
}

// set_max_procs changes the number of active processors.
// Returns the previous value. Translated from Go's GOMAXPROCS().
pub fn set_max_procs(n int) int {
	old := int(gomaxprocs)
	if n < 1 || n == old {
		return old
	}

	// TODO: implement full procresize like Go does
	// For now, just update the count
	gomaxprocs = i32(n)
	return old
}

// num_goroutine returns the number of goroutines that currently exist.
pub fn num_goroutine() int {
	allgs_mu.acquire()
	mut count := 0
	for g in allgs {
		if g.status != .dead {
			count++
		}
	}
	allgs_mu.release()
	return count
}

// shutdown gracefully shuts down the goroutine scheduler.
pub fn shutdown() {
	gsched.stopped = true
	// Wake all idle M's so they can exit
	gsched.mu.acquire()
	mut mp := gsched.midle
	for mp != unsafe { nil } {
		mp.park.post()
		mp = mp.sched_link
	}
	gsched.mu.release()
}