import time

interface MyInterface {
	foo() string
}

struct MyStruct {
pub mut:
	fooer shared MyInterface
}

struct MyImplementor {
mut:
	num int
}

fn (m MyImplementor) foo() string {
	// Can read member properties:
	num := m.num
	return 'Hello World ${num}!'
}

fn test_shared_interface_lock_1() {
	shared imp1 := MyImplementor{
		num: 1
	}
	s1 := MyStruct{
		fooer: imp1
	}
	lock s1.fooer {
		assert s1.fooer.foo() == 'Hello World 1!'
	}
}

fn test_shared_interface_lock_2() {
	shared imp := MyOtherImplementor{
		x: 1
		y: 2
		s: 'testing'
	}
	s := MyStruct{
		fooer: imp
	}

	lock s.fooer {
		assert s.fooer.foo() == 'Hello World (1, 2, testing)!'
	}

	// Lock is released and can be locked again:
	lock s.fooer {
		assert s.fooer.foo() == 'Hello World (1, 2, testing)!'
	}
}

fn test_shared_interface_lock_blocks_the_original_shared_value() {
	shared imp := MyImplementor{
		num: 6
	}
	s := MyStruct{
		fooer: imp
	}
	ready := chan bool{}
	proceed := chan bool{}
	done := chan bool{}
	task := spawn modify_shared_interface_impl(shared imp, ready, proceed, done)
	_ := <-ready
	lock s.fooer {
		proceed <- true
		select {
			_ := <-done {
				assert false, 'shared interface value was modified before the field lock was released'
			}
			20 * time.millisecond {}
		}
		assert s.fooer.foo() == 'Hello World 6!'
	}
	_ := <-done
	task.wait()
	lock s.fooer {
		assert s.fooer.foo() == 'Hello World 7!'
	}
}

fn modify_shared_interface_impl(shared x MyImplementor, ready chan bool, proceed chan bool, done chan bool) {
	ready <- true
	_ := <-proceed
	lock x {
		x.num++
	}
	done <- true
}

// TODO: Fix modifying shared interface value
// fn test_shared_interface_can_be_modified() {
// 	shared imp1 := MyImplementor{num: 6}
// 	shared imp2 := MyOtherImplementor{
// 		x: 7
// 		y: 3
// 		s: 'here be dragons...'
// 	}
// 	s := MyStruct{
// 		fooer: imp1
// 	}
// 	lock s.fooer {
// 		assert(s.fooer.foo() == 'Hello World 6!')
// 		s.fooer = imp2
// 	}
// 	lock s.fooer {
// 		assert(s.fooer.foo() == 'Hello World (7, 3, here be dragons...)!')
// 	}
// }

struct MyOtherImplementor {
	x int
	y int
	s string
}

fn (m MyOtherImplementor) foo() string {
	// Different implementation:
	return 'Hello World (${m.x}, ${m.y}, ${m.s})!'
}