import time

type MyAlias = []int
type MySumType = []f64 | []int

struct Test {
}

struct StructType2 {
	a ?time.Time
}

struct StructType {
mut:
	a string
	b ?int
	c ?f64
	d ?[]string
	e ?MyAlias
	f ?MySumType
}

struct Decoder {}

fn (d &Decoder) decode[T](mut typ T) T {
	$for field in T.fields {
		$if field.is_option {
			if typ.$(field.name) != none {
				dump(typ.$(field.name) ?.str())
			}
			typ.$(field.name) = none
		}
	}
	return typ
}

fn test_comptime() {
	d := Decoder{}
	result := d.decode(mut StructType{
		a: 'foo'
		b: 3
	})
	println(result)
}

fn test_cast_option() {
	mut x := ?int(123)
	dump(x)
	assert x != none
	x = none
	assert x == none
	dump(x)
}

fn test_assign_from_option() {
	mut x := ?int(123)
	mut y := x
	println(y)
	assert x != none
	assert y != none
	assert x? == 123
	assert y? == 123
}

fn test_blank_assign() {
	_ := ?bool(false)
}

fn test_optional_value_assign() {
	x := ?int(0)
	assert x != none
	assert x? == 0
}

fn test_assert_initialized() {
	mut x := ?int(1)
	mut y := ?int(1)
	assert x != none
	assert y != none
}

fn test_comptime_checks() {
	val := StructType{
		a: 'foo'
		b: 3
	}
	$for field in StructType.fields {
		value := val.$(field.name)
		$if field.is_option {
			var := val.$(field.name)
			var2 := var
			dump(var)
			dump(var2)
		}
	}
}

fn test_none_initialization() {
	mut var := ?int(none)
	mut var2 := ?int(none)
	mut var3 := ?int(none)

	assert var == none
	assert var2 == none
	assert var3 == none

	var = 1
	var2 = 2
	var3 = 3

	assert var? == 1
	assert var2? == 2
	assert var3? == 3

	assert var != none
	assert var2 != none
	assert var3 != none
}

fn test_as_cast() {
	var := StructType2{}
	b := var.a as ?time.Time
}

fn test_unwrap() {
	var := ?int(1)
	println(var)
	assert var != none
	assert var? == 1

	var2 := var? + 1
	println(var2)

	assert var2 == 2
}

fn test_or_block() {
	var1 := ?int(none)
	var2 := var1 or { 0 }
	var3 := var1 or { 1 }
	assert var2 + var3 == 1
	var4 := var1 or {
		t := 1 + var3
		t
	}

	assert var4 == 2
}

fn test_default_values() {
	var_none := ?f64(none)
	var_none2 := ?string(none)

	var2 := var_none or { 1.0 }
	println(var2)
	assert var2 == 1.0

	var3 := var_none2 or { 'foo' }
	println(var3)
	assert var3 == 'foo'
}

fn test_assert_option() {
	var1 := ?int(none)
	varz := ?f64(none)
	assert var1 == none

	var2 := var1 or { 1 }

	assert var1 == none
	assert var2 == 1

	println(var2)

	var3 := varz or { 0.0 }
	assert var3 == 0

	var4 := varz
	assert var4 == none
}

fn test_opt_assign() {
	mut var1 := ?int(none)
	assert var1 == none
	var1 = 1
	assert var1 != none
	var2 := var1
	assert var2? == var1?
}

fn test_opt_none() {
	mut t1 := ?int(none)
	t2 := ?int(none)

	t1 = t2
	assert t1 == none
	assert t2 == none

	mut t3 := ?Test{}
	t4 := t3
	assert t4 == none
	assert t3 == none

	mut t5 := ?map[string]string{}
	t7 := {
		'foo': 'bar'
	}
	t6 := if t5 != none { t5.clone() } else { t7 }
	assert t5 == none
	assert t6.len == 1
}