import time

struct St1 {
	val     int = 5
	another chan f64
}

fn fn1(c chan St1) string {
	println('1')
	println(c)
	x := <-c
	println(x)
	return x.str()
}

fn test_printing_of_channels() {
	ch := chan St1{cap: 10}
	fch := chan f64{cap: 100}
	ch <- St1{
		val:     1000
		another: fch
	}
	res := (spawn fn1(ch)).wait()
	println(res)
	println(ch)
	assert res.str().contains('another: chan f64{\n        cap: 100, closed: false\n    }')
	assert ch.str() == 'chan St1{\n    cap: 10, closed: false\n}'
	assert fch.str() == 'chan f64{\n    cap: 100, closed: false\n}'
	fch.close()
	assert fch.str() == 'chan f64{\n    cap: 100, closed: true\n}'
}

struct Aa {}

struct Ab {}

type As = Aa | Ab

fn func(ch chan As) {
	ch <- Aa{}
}

fn test_chan_of_sumtype() {
	a := chan As{}
	spawn func(a)
	ret := <-a
	println(ret)
	assert '${ret}' == 'As(Aa{})'
}

struct Iter[T] {
	item chan T
}

fn new_iter[T](ch chan T) Iter[T] {
	return Iter[T]{
		item: ch
	}
}

fn (self Iter[T]) next() ?T {
	self.item.close()
	ch := <-self.item or { return none }
	return ch
}

fn test_channel_with_or_block() {
	ch := chan int{}
	iter := new_iter[int](ch)
	ret := iter.next() or {
		assert true
		return
	}
	println(ret)
	assert false
}

fn test_closed_channel_returns_zero_value_struct() {
	ch := chan time.Time{}
	ch.close()
	got := <-ch
	assert got == time.Time{}
	assert got.str() == '0000-00-00 00:00:00'
}