struct Dog {
	breed string
}

struct Cat {
mut:
	breed string
}

fn new_cat(breed string) Cat {
	return Cat{breed}
}

fn (c &Cat) name() string {
	if c.breed != '' {
		assert c.breed == 'Persian'
	}
	return 'Cat'
}

fn (c &Cat) speak(s string) {
	if c.breed != '' {
		assert c.breed == 'Persian'
	}
	assert s == 'Hi !'
	println('meow')
}

fn (c Cat) name_detailed(pet_name string) string {
	return '${pet_name} the ${typeof(c).name}, breed:${c.breed}'
}

fn (mut c Cat) set_breed(new string) {
	c.breed = new
}

// utility function to override default conversion to string, as a sample
fn (c Cat) str() string {
	return 'Custom string conversion for Cat: ${c.breed}'
}

fn (d Dog) speak(s string) {
	assert s == 'Hi !'
	println('woof')
}

fn (d Dog) name() string {
	assert d.breed == 'Labrador Retriever'
	return 'Dog'
}

fn (d Dog) name_detailed(pet_name string) string {
	return '${pet_name} the ${typeof(d).name}, breed:${d.breed}'
}

fn (mut d Dog) set_breed(new string) {
	println('Nah')
}

// do not add to Dog the utility function 'str', so the default one will be used, as a sample

struct Bird {
mut:
	breed string
}

fn (b Bird) speak(s string) {
	println('tweet')
}

fn (b Bird) name() string {
	return b.breed
}

fn (b Bird) name_detailed(pet_name string) string {
	return '${pet_name} the ${typeof(b).name}, breed:${b.breed}'
}

fn (mut b Bird) set_breed(new string) {
	println('canary')
	b.breed = new
}

// do not add to Bird the utility function 'str', so the default one will be used, as a sample

fn is_dog_or_cat(a Animal) bool {
	is_dog := a is Dog
	is_cat := a is Cat
	println('Animal is Dog or Cat: is a Dog: ${is_dog}, is a Cat: ${is_cat}')
	// return is_dog || is_cat
	// shorter syntax
	is_dog_or_cat := if a is Dog || a is Cat { true } else { false }
	println('Animal is Dog or Cat: ${is_dog_or_cat}')
	return is_dog_or_cat
}

fn is_dog_or_cat_or_bird(a Animal) bool {
	ret := a is Dog || a is Cat || a is Bird
	println('Animal is Dog or Cat or Bird: ${ret}')
	return ret
}

fn perform_speak(a Animal) {
	println('---- ${@FN}, given Animal: ${a} ----')
	a.speak('Hi !')
	assert true
	name := a.name()
	assert name == 'Dog' || name == 'Cat'
	if a is Dog {
		assert name == 'Dog'
		assert a.breed == 'Labrador Retriever' // test smart casting
		println(a.breed)
	}
	println(a.name())
	println('Got animal of type: ${typeof(a).name}') // TODO: get implementation type (if possible)
	assert a is Dog || a is Cat
	assert is_dog_or_cat(a)
}

fn perform_speak_on_ptr(a &Animal) {
	println('---- ${@FN}, given &Animal: ${a} ----')
	a.speak('Hi !')
	assert true
	name := a.name()
	assert name == 'Dog' || name == 'Cat'
	if a is Dog {
		assert name == 'Dog'
	}
	println(a.name())
	println('Got animal of type: ${typeof(a).name}') // TODO: get implementation type (if possible)
	assert a is Dog || a is Cat
	assert is_dog_or_cat(a)
}

fn test_perform_speak() {
	println('---- ${@FN} ----')
	dog := Dog{
		breed: 'Labrador Retriever'
	}
	perform_speak(dog)
	perform_speak_on_ptr(dog)
	cat := Cat{
		breed: 'Persian'
	}
	perform_speak(cat)
	perform_speak(Cat{
		breed: 'Persian'
	})
	perform_speak(new_cat('Persian'))
	perform_speak_on_ptr(cat)
	perform_speak_on_ptr(Cat{
		breed: 'Persian'
	})
	perform_speak_on_ptr(new_cat('Persian'))
	handle_animals([dog, cat])
}

fn change_animal_breed(mut a Animal, new string) {
	a.set_breed(new)
}

fn test_interface_ptr_modification() {
	println('---- ${@FN} ----')
	mut cat := Cat{
		breed: 'Persian'
	}
	change_animal_breed(mut cat, 'Siamese')
	assert cat.breed == 'Siamese'
}

fn perform_name_detailed(a Animal) {
	name_full := a.name_detailed('MyPet')
	println(name_full)
	assert name_full.starts_with('MyPet the Dog') || name_full.starts_with('MyPet the Cat')
}

fn test_perform_name_detailed() {
	println('---- ${@FN} ----')
	dog := Dog{
		breed: 'Labrador Retriever'
	}
	println('Test on Dog: ${dog} ...') // using default conversion to string
	perform_name_detailed(dog)
	cat := Cat{}
	println('Test on empty Cat: ${cat} ...')
	perform_speak(cat)
	println('Test on a Persian Cat: ...')
	perform_speak(Cat{
		breed: 'Persian'
	})
	cat_persian2 := Cat{
		breed: 'Persian'
	}
	println('Test on another Persian Cat: "${cat_persian2}" ...')
	perform_speak(cat_persian2)
	cat_persian2_str := cat_persian2.str()
	println("Persian Cat 2: '${cat_persian2_str}' ...")
	assert cat_persian2_str == 'Custom string conversion for Cat: Persian'
	println('Test (dummy/empty) on array of animals ...')
	handle_animals([dog, cat])
	handle_animals_mutable([dog, cat])
	assert true
}

fn handle_animals(a []Animal) {
}

fn handle_animals_mutable(a []Animal) {
}

interface Register {
	register()
}

struct RegTest {
	a int
}

fn (f RegTest) register() {
}

fn handle_reg(r Register) {
	r.register()
}

fn test_register() {
	println('---- ${@FN} ----')
	f := RegTest{}
	f.register()
	handle_reg(f)
}

interface Speaker2 {
	name() string
	speak()
	return_speaker() Speaker2
mut:
	return_speaker2() ?Speaker2
}

struct Boss {
mut:
	name string
}

fn (b Boss) name() string {
	return b.name
}

fn (b Boss) speak() {
	println("i'm ${b.name}")
}

fn (b &Boss) return_speaker() Speaker2 {
	return b
}

fn (mut b Boss) return_speaker2() ?Speaker2 {
	if b.name == 'richard' {
		return none
	}
	b.name = 'boss'
	return b
}

fn return_speaker2(mut sp Speaker2) Speaker2 {
	s := sp.return_speaker()
	s2 := sp.return_speaker2() or { return *sp }
	s.speak()
	s2.speak()
	return s2
}

fn test_interface_returning_interface() {
	mut b := Boss{'bob'}
	assert b.name == 'bob'
	s2 := return_speaker2(mut b)
	if s2 is Boss {
		assert s2.name == 'boss'
	}
}

struct Foo {
	animal  Animal
	animals []Animal
}

interface Animal {
	name() string
	name_detailed(pet_name string) string
	speak(s string)
mut:
	set_breed(s string)
}

fn test_interface_array() {
	println('---- ${@FN} ----')
	println('Test on array of animals ...')
	mut animals := []Animal{}
	animals = [Cat{}, Dog{
		breed: 'Labrador Retriever'
	}]
	assert true
	animals << Cat{}
	assert true
	animals << Bird{}
	assert true
	// println('Animals array contains: ${animals.str()}') // explicit call to 'str' function
	println('Animals array contains: ${animals}') // implicit call to 'str' function
	assert animals.len == 4
}

fn test_interface_ptr_array() {
	println('---- ${@FN} ----')
	mut animals := []&Animal{}
	animals = [Cat{}, Dog{
		breed: 'Labrador Retriever'
	}]
	assert true
	animals << Cat{}
	assert true
	animals << Bird{}
	assert true
	// println('Animals array contains: ${animals.str()}') // explicit call to 'str' function
	println('Animals array contains: ${animals}') // implicit call to 'str' function
	assert animals.len == 4
}

fn test_is() {
	println('---- ${@FN} ----')
	dog := Dog{}
	assert is_dog_int(dog) == 1
}

fn is_dog_int(a Animal) int {
	if a is Dog {
		return 1
	} else {
		return 0
	}
}

fn test_is_bool() {
	println('---- ${@FN} ----')
	dog := Dog{}
	assert is_dog(dog) == true
	assert is_dog_or_cat(dog)
	cat := Cat{}
	assert is_dog(cat) == false
	assert is_dog_or_cat(cat)
	bird := Bird{}
	assert is_dog(bird) == false
	assert !is_dog_or_cat(bird)
	assert is_dog_or_cat_or_bird(bird)
}

fn is_dog(a Animal) bool {
	println("Got animal: '${a}'") // implicit call to 'str' function of implementations
	println('with type: ${typeof(a).name}') // get implementation type (if possible)

	// sample (additional checks) here
	is_dog_or_cat := if a is Dog || a is Cat { true } else { false }
	println('Animal is Dog or Cat: ${is_dog_or_cat}')

	// use/test even another syntax
	if a is Dog {
		return true
	} else {
		return false
	}
}

fn new_animal() Animal {
	dog := Dog{}
	return dog
}

fn new_animal2() Animal {
	return new_animal()
}

/*
// TODO
fn animal_match(a Animal) {
	match a {
		Dog { println('(dog)') }
		Cat { println('(cat)') }
		else { println('(other)' }
	}
}
*/

interface II {
mut:
	my_field int
}

struct AA {
	BB
}

struct BB {
	pad [10]u8
mut:
	my_field int
}

// the opposite example of interface_mutability_receiver.vv
// 	 related to https://github.com/vlang/v/issues/1081 and https://github.com/vlang/v/issues/7338
//   test example code by https://github.com/nedpals copied and adapted from https://github.com/vlang/v/issues/7338
// we accept immutable get_name even if the interface specified `mut` as it is consistent with function param behavior
struct Dog2 {
pub mut:
	name string
}

fn (d Dog2) get_name() string {
	return d.name
}

// mut get_name might be a bad example
// we try to show that an interface can be more liberal in mut than the implementor,
// while our error check is for the opposite case
interface Animal2 {
mut:
	get_name() string
}

fn get_animal_name(mut a Animal2) string {
	return a.get_name()
}

fn test_aa() {
	println('---- ${@FN} ----')
	mut aa := AA{}
	mut ii := II(aa)
	assert ii.my_field == 0
	aa.my_field = 123
	assert ii.my_field == 123
	ii.my_field = 1234
	assert aa.my_field == 1234
	mut dog := Dog2{'Doggo'}
	println(dog.name)
	println(get_animal_name(mut dog))
}

type Text = string

fn (t Text) display() string {
	return t
}

interface Displayable {
	display() string
}

fn print_displayable(ds ...Displayable) {
	for d in ds {
		println(d.display())
	}
}

fn test_variadic_interface() {
	print_displayable(Text('test'), Text('hehe'))
}

interface MyError {
	print_error()
}

struct CustomError implements MyError {
}

fn (e CustomError) print_error() {
}

fn handle_implements(e MyError) {
	e.print_error()
}

fn test_implements() {
	e := CustomError{}
	handle_implements(e)
	println('implements ok')
}

interface VtableDrawable {
	draw() int
}

interface VtableCalculator {
	add(a int, b int) int
	multiply(x int) int
}

struct VtablePoint {
	x int
	y int
}

fn (p VtablePoint) draw() int {
	return p.x * 1000 + p.y
}

fn (p VtablePoint) add(a int, b int) int {
	return p.x + p.y + a + b
}

fn (p VtablePoint) multiply(x int) int {
	return (p.x + p.y) * x
}

fn test_interface_value_receiver_dispatch() {
	p1 := VtablePoint{
		x: 7
		y: 3
	}
	d1 := VtableDrawable(p1)
	assert d1.draw() == 7003

	p2 := VtablePoint{
		x: 15
		y: 25
	}
	d2 := VtableDrawable(p2)
	assert d2.draw() == 15025

	p3 := VtablePoint{
		x: 1
		y: 1
	}
	d3 := VtableDrawable(p3)
	assert d3.draw() + d3.draw() == 2002
}

fn test_interface_value_receiver_dispatch_with_params() {
	calc := VtableCalculator(VtablePoint{
		x: 10
		y: 5
	})
	assert calc.add(3, 7) == 25
	assert calc.multiply(4) == 60

	calc2 := VtableCalculator(VtablePoint{
		x: 2
		y: 3
	})
	assert calc2.add(1, 1) == 7
	assert calc2.multiply(10) == 50
}