@[has_globals]
module main

// vtest retry: 2
import sync

fn one() int {
	return 1
}

fn pushf64() {
	ch <- 12.5
}

fn test_global_init() {
	intmap['two'] = 27
	key := 'two'
	assert intmap[key] == 27
	t := spawn pushf64()
	numberfns['one'] = one
	numberfns['two'] = fn () int {
		return 2
	}
	f := numberfns['one']
	n := f()
	assert n == 1
	m := numberfns['two']()
	assert m == 2
	got := <-ch
	assert got == 12.5
	t.wait()
	assert true
}

fn get_u64() u64 {
	return 27
}

fn test_no_type() {
	assert test == 0
	assert typeof(test).name == 'int'
	assert testf == 1.25
	assert typeof(testf).name == 'f64'
	assert testneg == -2
	assert typeof(testneg).name == 'int'
	assert testnegf == -1250000
	assert typeof(testnegf).name == 'f64'
	assert testexpl == 7
	assert typeof(testexpl).name == 'f32'
	assert testfn == 27
	assert typeof(testfn).name == 'u64'
	assert typeof(testarr).name == '[]f64'
	assert testarr.len == 10
	assert testarr[9] == 2.75
	assert typeof(testmap).name == 'map[string]f64'
	assert testmap['asd'] == -7.25
}

fn test_fn_type() {
	assert func2(22) == 22
	assert func3(22) == '22'
}

__global (
	intmap    map[string]int
	numberfns map[string]fn () int
	ch        chan f64
	mys       shared MyStruct
	sem       sync.Semaphore
	shmap     shared map[string]f64
	mtx       sync.RwMutex
	f1        = f64(545 / (sizeof(f64) + f32(8))) // directly initialized
	f2        f64
	test      = 0 // int
	testf     = 1.25 // f64
	testneg   = -2 // int
	testnegf  = -1.25e06 // f64
	testexpl  = f32(7)
	testfn    = get_u64()
	testarr   = []f64{len: 10, init: 2.75}
	testmap   = {
		'qwe': 2.5
		'asd': -7.25
		'yxc': 3.125
	}
	func1     = fn () {}
	func2     = fn (n int) int {
		return n
	}
	func3     = fn (n int) string {
		return '${n}'
	}
)

fn init() {
	// semaphores and mutexes must not be moved in memory, so for technical
	// reasons they cannot have a "default constructor" at the moment and must
	// be initialized "manually"
	sem.init(0)
	mtx.init()
}

struct MyStruct {
mut:
	x f64
	y f64
}

fn switch() {
	for !sem.try_wait() {
		lock mys {
			if mys.x == 13.0 {
				mys.x = 13.75
			} else if mys.y == 13.0 {
				mys.y = 13.75
			}
		}
		lock mys {
			mys.x, mys.y = mys.y, mys.x
		}
	}
}

fn test_global_shared() {
	lock mys {
		mys.x = 13.0
		mys.y = -35.125
	}
	t := spawn switch()
	for _ in 0 .. 2500000 {
		lock mys {
			mys.x, mys.y = mys.y, mys.x
		}
	}
	a, b := rlock mys {
		mys.x, mys.y
	}
	sem.post()
	t.wait()
	eprintln('> a: ${a} | b: ${b}')
	c1 := dump(a == 13.75 && b == -35.125)
	c2 := dump(a == -35.125 && b == 13.75)
	assert c1 || c2
}

fn test_global_shared_map() {
	lock shmap {
		shmap['one'] = 1.25
		shmap['two'] = -0.75
	}
	x, y := rlock shmap {
		shmap['two'], shmap['one']
	}
	assert x == -0.75
	assert y == 1.25
}

fn switch2() u64 {
	mut cnt := u64(0)
	for {
		cnt++
		mtx.lock()
		f1, f2 = f2, f1
		if f1 == 17.0 || f2 == 17.0 {
			mtx.unlock()
			return cnt
		}
		mtx.unlock()
	}
	return 0
}

fn test_global_mutex() {
	assert f1 == 34.0625
	t := spawn switch2()
	for _ in 0 .. 25000 {
		mtx.lock()
		f1, f2 = f2, f1
		mtx.unlock()
	}
	mtx.lock()
	if f1 == 0.0 {
		f1 = 17.0
	} else {
		f2 = 17.0
	}
	mtx.unlock()
	mtx.rlock()
	assert (f1 == 17.0 && f2 == 34.0625) || (f1 == 34.0625 && f2 == 17.0)
	mtx.runlock()
	n := t.wait()
	eprintln('> n: ${n} | f1: ${f1} | f2: ${f2}')
	assert n > 0
}
