// 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 parking (blocking/unblocking) mechanism.
// Translated from Go's gopark/goready in proc.go.
//
// When a goroutine needs to block (e.g., waiting on a channel),
// it "parks" itself - yielding its M to the scheduler.
// When the condition is met, another goroutine "readies" it
// by putting it back on a run queue.
module goroutines

// gopark puts the current goroutine into a waiting state.
// The goroutine can be made runnable again by calling goready.
// reason describes why the goroutine is parking (for debugging).
// Translated from Go's gopark() in proc.go.
pub fn gopark(reason string) {
	mut mp := get_current_m()
	if mp == unsafe { nil } {
		return
	}
	mut gp := mp.curg
	if gp == unsafe { nil } {
		return
	}

	gp.status = .waiting
	gp.wait_reason = reason

	// Dissociate G from M
	mp.curg = unsafe { nil }
	gp.m = unsafe { nil }

	// Switch back to the scheduler (M's g0 context)
	context_switch(mut &gp.context, &mp.g0.context)
}

// goready puts a waiting goroutine back on a run queue.
// Translated from Go's goready() in proc.go.
pub fn goready(gp &Goroutine) {
	if gp == unsafe { nil } {
		return
	}
	mut g := unsafe { gp }
	if g.status != .waiting {
		return
	}
	g.status = .runnable
	g.wait_reason = ''

	// Put it on the current P's local run queue, or global if no P
	mut pp := get_current_p()
	if pp != unsafe { nil } {
		runq_put(mut pp, g, true)
	} else {
		glob_runq_put(g)
	}

	// Try to wake an idle P to run this goroutine
	wake_p()
}

// gosched yields the processor, allowing other goroutines to run.
// Translated from Go's Gosched() / goschedImpl() in proc.go.
pub fn gosched() {
	mut mp := get_current_m()
	if mp == unsafe { nil } {
		return
	}
	mut gp := mp.curg
	if gp == unsafe { nil } {
		return
	}
	mut pp := mp.p
	if pp == unsafe { nil } {
		return
	}

	// Put the current G back on the run queue as runnable
	gp.status = .runnable
	mp.curg = unsafe { nil }
	gp.m = unsafe { nil }

	// Put on local queue
	runq_put(mut pp, gp, false)

	// Switch back to scheduler
	context_switch(mut &gp.context, &mp.g0.context)
}

// Sudog represents a G in a wait list (e.g., channel wait queue).
// Translated from Go's sudog struct in runtime2.go.
pub struct Sudog {
pub mut:
	g       &Goroutine = unsafe { nil } // the waiting goroutine
	next    &Sudog     = unsafe { nil } // next in wait list
	prev    &Sudog     = unsafe { nil } // prev in wait list
	elem    voidptr // data element (may point to stack)
	success bool    // true if woken by successful channel op
	c       voidptr // channel pointer
}

// WaitQ is a wait queue of Sudogs (used by channels).
// Translated from Go's waitq struct in runtime2.go.
pub struct WaitQ {
pub mut:
	first &Sudog = unsafe { nil }
	last  &Sudog = unsafe { nil }
}

pub fn (mut q WaitQ) enqueue(s &Sudog) {
	mut sg := unsafe { s }
	sg.next = unsafe { nil }
	sg.prev = q.last
	if q.last != unsafe { nil } {
		q.last.next = sg
	} else {
		q.first = sg
	}
	q.last = sg
}

pub fn (mut q WaitQ) dequeue() &Sudog {
	sg := q.first
	if sg == unsafe { nil } {
		return unsafe { nil }
	}
	q.first = sg.next
	if q.first != unsafe { nil } {
		q.first.prev = unsafe { nil }
	} else {
		q.last = unsafe { nil }
	}
	mut s := unsafe { sg }
	s.next = unsafe { nil }
	s.prev = unsafe { nil }
	return s
}

pub fn (q &WaitQ) empty() bool {
	return q.first == unsafe { nil }
}