// 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.
//
// Channel implementation for goroutines.
// Translated from Go's runtime/chan.go.
//
// Channels provide goroutine-safe communication between goroutines.
// They support both buffered and unbuffered modes.
//
// Key operations translated from Go:
//   - makechan()  -> chan_make()
//   - chansend()  -> chan_send()
//   - chanrecv()  -> chan_recv()
//   - closechan() -> chan_close()
module goroutines

// Chan is a goroutine-safe channel for communication between goroutines.
// Translated from Go's hchan struct in chan.go.
pub struct Chan {
pub mut:
	mu       SpinLock // protects all fields (spinlock is ucontext-safe)
	qcount   u32      // total data in the queue
	dataqsiz u32      // size of the circular buffer
	buf      voidptr  // circular buffer for buffered channels
	elemsize u16      // size of each element
	closed   bool     // true if channel is closed

	sendx u32 // send index into circular buffer
	recvx u32 // receive index into circular buffer

	recvq WaitQ // list of recv waiters
	sendq WaitQ // list of send waiters
}

// chan_make creates a new channel.
// If buf_size > 0, creates a buffered channel.
// Translated from Go's makechan() in chan.go.
pub fn chan_make(elem_size int, buf_size int) &Chan {
	mut c := &Chan{
		elemsize: u16(elem_size)
		dataqsiz: u32(buf_size)
	}
	if buf_size > 0 {
		c.buf = unsafe { malloc(elem_size * buf_size) }
	}
	return c
}

// chan_send sends a value on the channel.
// If block is true, blocks until the send can proceed.
// Returns true if the value was sent.
// Translated from Go's chansend() in chan.go.
pub fn chan_send(c &Chan, ep voidptr, block bool) bool {
	if c == unsafe { nil } {
		if !block {
			return false
		}
		// Block forever on nil channel (Go behavior)
		gopark('chan send (nil chan)')
		return false // unreachable
	}

	mut ch := unsafe { c }
	ch.mu.acquire()

	if ch.closed {
		ch.mu.release()
		panic('send on closed channel')
	}

	// Fast path: try to find a waiting receiver
	sg := ch.recvq.dequeue()
	if sg != unsafe { nil } {
		// Found a waiting receiver - send directly
		ch.mu.release()
		send_direct(sg, ep, ch.elemsize)
		return true
	}

	// Buffered channel with space available
	if ch.qcount < ch.dataqsiz {
		// Put data in buffer
		dst := chan_buf(ch, ch.sendx)
		unsafe { C.memcpy(dst, ep, ch.elemsize) }
		ch.sendx++
		if ch.sendx == ch.dataqsiz {
			ch.sendx = 0
		}
		ch.qcount++
		ch.mu.release()
		return true
	}

	if !block {
		ch.mu.release()
		return false
	}

	// Block: enqueue ourselves on the send wait queue
	gp := get_current_g()
	mut mysg := &Sudog{
		g:    unsafe { gp }
		elem: ep
		c:    voidptr(ch)
	}
	ch.sendq.enqueue(mysg)
	ch.mu.release()

	// Park the goroutine until a receiver wakes us
	gopark('chan send')

	return true
}

// chan_recv receives a value from the channel.
// If block is true, blocks until a value is available.
// Returns (received, ok). ok is false if channel is closed and empty.
// Translated from Go's chanrecv() in chan.go.
pub fn chan_recv(c &Chan, ep voidptr, block bool) (bool, bool) {
	if c == unsafe { nil } {
		if !block {
			return false, false
		}
		gopark('chan receive (nil chan)')
		return false, false // unreachable
	}

	mut ch := unsafe { c }
	ch.mu.acquire()

	// Fast path: try to find a waiting sender
	sg := ch.sendq.dequeue()
	if sg != unsafe { nil } {
		ch.mu.release()
		recv_direct(ch, sg, ep)
		return true, true
	}

	// Buffered channel with data available
	if ch.qcount > 0 {
		src := chan_buf(ch, ch.recvx)
		if ep != unsafe { nil } {
			unsafe { C.memcpy(ep, src, ch.elemsize) }
		}
		ch.recvx++
		if ch.recvx == ch.dataqsiz {
			ch.recvx = 0
		}
		ch.qcount--
		ch.mu.release()
		return true, true
	}

	if ch.closed {
		ch.mu.release()
		if ep != unsafe { nil } {
			unsafe { C.memset(ep, 0, ch.elemsize) }
		}
		return true, false
	}

	if !block {
		ch.mu.release()
		return false, false
	}

	// Block: enqueue ourselves on the recv wait queue
	gp := get_current_g()
	mut mysg := &Sudog{
		g:    unsafe { gp }
		elem: ep
		c:    voidptr(ch)
	}
	ch.recvq.enqueue(mysg)
	ch.mu.release()

	// Park until a sender wakes us
	gopark('chan receive')

	return true, true
}

// chan_close closes the channel.
// Translated from Go's closechan() in chan.go.
pub fn chan_close(c &Chan) {
	if c == unsafe { nil } {
		panic('close of nil channel')
	}

	mut ch := unsafe { c }
	ch.mu.acquire()

	if ch.closed {
		ch.mu.release()
		panic('close of closed channel')
	}

	ch.closed = true

	// Wake all waiting receivers
	for {
		mut sg := ch.recvq.dequeue()
		if sg == unsafe { nil } {
			break
		}
		if sg.elem != unsafe { nil } {
			unsafe { C.memset(sg.elem, 0, ch.elemsize) }
		}
		sg.success = false
		goready(sg.g)
	}

	// Wake all waiting senders (they will panic)
	for {
		mut sg := ch.sendq.dequeue()
		if sg == unsafe { nil } {
			break
		}
		sg.success = false
		goready(sg.g)
	}

	ch.mu.release()
}

// send_direct sends data directly from sender to a waiting receiver.
// Translated from Go's send() in chan.go.
fn send_direct(sg &Sudog, ep voidptr, elem_size u16) {
	if sg.elem != unsafe { nil } {
		unsafe { C.memcpy(sg.elem, ep, elem_size) }
	}
	mut s := unsafe { sg }
	s.success = true
	goready(sg.g)
}

// recv_direct receives data directly from a waiting sender.
fn recv_direct(ch &Chan, sg &Sudog, ep voidptr) {
	if ch.dataqsiz == 0 {
		// Unbuffered: copy directly from sender
		if ep != unsafe { nil } {
			unsafe { C.memcpy(ep, sg.elem, ch.elemsize) }
		}
	} else {
		// Buffered: take from buffer, then copy sender's data into buffer
		buf_elem := chan_buf(ch, unsafe { ch }.recvx)
		if ep != unsafe { nil } {
			unsafe { C.memcpy(ep, buf_elem, ch.elemsize) }
		}
		unsafe { C.memcpy(buf_elem, sg.elem, ch.elemsize) }
		unsafe {
			ch.recvx++
			if ch.recvx == ch.dataqsiz {
				ch.recvx = 0
			}
			ch.sendx = ch.recvx
		}
	}
	mut s := unsafe { sg }
	s.success = true
	goready(sg.g)
}

// chan_buf returns a pointer to the i-th slot in the buffer.
// Translated from Go's chanbuf() in chan.go.
fn chan_buf(c &Chan, i u32) voidptr {
	return unsafe { voidptr(usize(c.buf) + usize(i) * usize(c.elemsize)) }
}

// chan_len returns the number of elements in the channel buffer.
pub fn chan_len(c &Chan) int {
	if c == unsafe { nil } {
		return 0
	}
	return int(c.qcount)
}

// chan_cap returns the capacity of the channel buffer.
pub fn chan_cap(c &Chan) int {
	if c == unsafe { nil } {
		return 0
	}
	return int(c.dataqsiz)
}