import time
// 1 line comment // 1 line comment

/*
multi line comment (1)
multi line comment (2)
multi line comment (3)
*/
/*
multi line comment (1)
    /*
        nested comment
    */
    /*nested comment*/
    /*nested comment
*/
    /* nested comment */
    /* /* nested comment */ */
    multi line comment (2)
*/
type MyFn1 = fn (int) string

type MyFn2 = fn (a int, b int) int

type MyFn3 = fn (int, int)

fn myfn4(string)

fn foobar()

fn slopediv(num u32, den u32) int

type F1 = fn ()

type F2 = fn (voidptr)

type F3 = fn (voidptr, voidptr)

type F4 = fn (voidptr) int

type F5 = fn (int, int) int

type F6 = fn (int, int)

type F7 = fn (time.Time, int)

type MyTime = time.Time
type F8 = fn (MyTime)

interface MyInterface {}

type F9 = fn (MyInterface)

fn C.atoi(const_s &char) i32
fn C.freec(ptr voidptr)

@[trusted]
fn C.exitc(code i32)

// above checks attribute doesn't conflict with `freec` return type

fn foo() {
}

type ActionfV = fn ()

type ActionfP1 = fn (voidptr)

type ActionfP2 = fn (voidptr, voidptr)

// TODO
fn modify_array(mut a []int) {
    a[0] = 10
    for i in 0 .. a.len {
        a[i] = a[i] * 2
    }
    // a << 888
}

fn modify_array2(mut a []int) {
    a[0] = 10
    for i in 0 .. a.len {
        a[i] = a[i] * 2
    }
    // a << 888
}

fn test_mut_array() {
    mut nums := [1, 2, 3]
    modify_array(mut nums)
    // assert nums.len == 4
    // println(nums)
    assert nums[0] == 20
    assert nums[1] == 4
    assert nums[2] == 6
    // assert nums[3] == 888
    // workaround for // [91, 32, -33686272] windows bug
    println(nums.clone())
}

fn mod_struct(mut user User) {
    user.age++
}

struct User {
mut:
    age int
}

fn test_mut_struct() {
    mut user := User{18}
    mod_struct(mut user)
    assert user.age == 19
}

/*
fn mod_ptr(mut buf &byte) {
    buf[0] = 77
}

fn test_mut_ptr() {
    buf := malloc(10)
    mod_ptr(mut buf)
    assert buf[0] == 77
}
*/

fn assert_in_bool_fn(v int) bool {
    assert v < 3
    return true
}

fn test_assert_in_bool_fn() {
    assert_in_bool_fn(2)
}

type MyFn = fn (int) int

fn test(n int) int {
    return n + 1000
}

struct MySt {
    f MyFn
}

fn test_fn_type_call() {
    mut arr := []MyFn{}
    arr << MyFn(test)
    // TODO: `arr[0](10)`
    // assert arr[0](10) == 1010
    x1 := arr[0]
    x2 := x1(10)
    assert x2 == 1010
    st := MySt{
        f: test
    }
    assert st.f(10) == 1010
    st1 := &MySt{
        f: test
    }
    assert st1.f(10) == 1010
}

fn ff() fn () int {
    return fn () int {
        return 22
    }
}

fn test_fn_return_fn() {
    f := ff()
    assert f() == 22
}

// Test new static methods

struct Foo {
    x int
}

struct Foo2 {
    x int
}

fn (f Foo) normal_method() {
}

fn Foo.static_method() int {
    return 7
}

fn Foo2.static_method() int {
    return 8
}

fn test_static_method() {
    x := Foo.static_method()
    assert x == 7
    x2 := Foo2.static_method()
    assert x2 == 8
}