// this file is just to test the parser so there may be a
// bunch of stuff in here that does not really make sense
module main

struct GenericStructA[T] {
    field_a T
}

struct GenericStructB[T,U] {
    field_a T
    field_b U
}

fn fn_generic_a[T](param_a T, param_b string, param_c int) int {
    println('fn_generic_a: ${param_a.type}, ${param_b.type}, ${param_c.type}')
    return 1
}

fn fn_generic_b[T,Y](param_a T, param_b Y) int {
    println('fn_generic_a: ${param_a.type}, ${param_b.type}')
}

fn fn_generic_c[fn[U,I](U, I) U, Y](param_a T, param_b Y) int {
    println('fn_generic_c')
    return 1
}

fn test_generic_struct_init() {
    a := GenericStructA[int] {
        field_a: 1
    }
}

fn fn_generic_init_a[T](param_a T) {
    // TODO: infer correct init after type checking
    // eg. array, chan, map, or struct init.
    mut a := T{}
    for k, v in param_a {
        a[k] = v
    }
    println(a)
}

fn test_generic_init() {
    fn_generic_init_a[map[string]string]({'a': 'apple'})
}

// assoc works with generic structs although
// this will probably never be supported or used
fn test_generic_assoc() {
        struct_a := GenericStructB[int,int]{field_a: 1, field_b: 2}
        assoc_struct_b := GenericStructB[int,int]{
        ...struct_b
        field_a: 10
        field_b: 20
    }
}

fn test_generic_call() {
    call_generic_a := fn_generic_a[GenericStructA](GenericStructA{}, 'string', 1)
    fn_generic_b[int,int](1,2)
}

fn test_generic_complex_or_nested() {
    fn_generic_c[fn[U,I](U, I) U, I](fn[U,I](param_a U, param_b I) U {}, 1)

    fn_generic_b[GenericStructA[Y],int](GenericStructA[int]{}, 1)
    fn_generic_b[GenericStructA[Y],GenericStructA[Y]](GenericStructA[int]{}, 1)
    struct_a := GenericStructA[int]{field_a: 1}

    fn_generic_b[[]string,map[string]string{}](1, 1) // TODO: error

    fn_a := fn(param_a string, param_b int, param_c int) {}
    fn_b := fn(param_a string, param_b int, param_c int) {}
    fn_c := fn(param_a string, param_b int, param_c int) {}
    fn_a('a', a < b, a < b, c)
    fn_a('a', foo: a < b, a < b, c)
    fn_b('a', fn_generic_c[fn[T,Y](int),int](1))
    fn_b('a', fn_generic_c[fn[T,Y](int),int](a < if (fn_generic_b[int,int](1,2) > 2) { 1 } else { 2 }, 2), 1)
    fn_b('a', moda.fn_generic_b[fn[T,Y](int),int](a < if (fn_generic_b[int,int](1,2) > 2) { 1 } else { 2 }, 2), fn_generic_b[int,int](1,2))
    fn_b('a', modb.submodb.fn_generic_b[int,int](fn_generic_b[int,int](fn_generic_b[int,int](1,2) < (fn_generic_b[int,int](1,2) - 2), 2)),fn_generic_b[int,int](1,2))
    
    fn_c(fn_generic_b[GenericStructB[int,int]](GenericStructB<int>{}, 1), moda.fn_generic_b[GenericStructB[int,int]](GenericStructB[int]{}, 1))
    fn_c(a < fn_generic_b[GenericStructB[GenericStructA[int],int]](GenericStructB[int]{}, 1), moda.fn_generic_b[GenericStructB[int,int]](GenericStructB<int>{}, 1))
    
    // return if x < 64 { fn_generic_b[int,int](1,2) } else { fn_generic_b[int,int](1, 2) < (fn_generic_b[int,int](1, 2) - 2) }
    return fn_generic_b[int,int](1, 2) < b, c > d, e < f, g > h, fn_generic_b[int,int](fn_generic_b[int,int](fn_generic_b[int,int](1, 2), 2), 2) > j, k < l, m
}