module main

struct Point {
mut:
    x int
    y int
}

struct Rect {
    origin Point
    width  int
    height int
}

enum Color {
    red
    green
    blue
}

enum Direction {
    up
    down
    left
    right
}

fn add(a int, b int) int {
    return a + b
}

fn multiply(a int, b int) int {
    return a * b
}

fn (p Point) sum() int {
    return p.x + p.y
}

fn (p Point) scale(factor int) Point {
    return Point{
        x: p.x * factor
        y: p.y * factor
    }
}

fn (r Rect) area() int {
    return r.width * r.height
}

fn max(a int, b int) int {
    if a > b {
        return a
    }
    return b
}

fn abs(n int) int {
    if n < 0 {
        return -n
    }
    return n
}

fn fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    mut a := 0
    mut b := 1
    for i := 2; i <= n; i++ {
        c := a + b
        a = b
        b = c
    }
    return b
}

fn color_name(c Color) string {
    if int(c) == 0 {
        return 'red'
    } else if int(c) == 1 {
        return 'green'
    } else if int(c) == 2 {
        return 'blue'
    }
    return 'unknown'
}

fn collatz_steps(start int) int {
    mut n := start
    mut steps := 0
    for n > 1 {
        if n % 2 == 0 {
            n = n / 2
        } else {
            n = n * 3 + 1
        }
        steps = steps + 1
    }
    return steps
}

fn sum_range(start int, end int) int {
    mut total := 0
    for i := start; i < end; i++ {
        total = total + i
    }
    return total
}

fn is_even(n int) bool {
    return n % 2 == 0
}

fn count_even(limit int) int {
    mut c := 0
    for i := 0; i < limit; i++ {
        if is_even(i) {
            c = c + 1
        }
    }
    return c
}

fn direction_dx(d Direction) int {
    if int(d) == 2 {
        return -1
    } else if int(d) == 3 {
        return 1
    }
    return 0
}

fn direction_dy(d Direction) int {
    if int(d) == 0 {
        return -1
    } else if int(d) == 1 {
        return 1
    }
    return 0
}

__global g_val int

fn fib_recursive(n int) int {
    if n <= 1 {
        return n
    }
    return fib_recursive(n - 1) + fib_recursive(n - 2)
}

fn factorial_recursive(n int) int {
    if n <= 1 {
        return 1
    }
    return n * factorial_recursive(n - 1)
}

fn gcd(a int, b int) int {
    if b == 0 {
        return a
    }
    return gcd(b, a % b)
}

fn power(base int, exp int) int {
    mut result := 1
    for i := 0; i < exp; i++ {
        result = result * base
    }
    return result
}

fn swap_point(mut p Point) {
    tmp := p.x
    p.x = p.y
    p.y = tmp
}

fn scale_point(mut p Point, factor int) {
    p.x = p.x * factor
    p.y = p.y * factor
}

fn nested_return(x int) int {
    if x < 10 {
        return 100
    } else {
        if x < 20 {
            return 200
        } else {
            return 300
        }
    }
}

fn sum_many(a int, b int, c int, d int, e int, f int, g int, h int) int {
    return a + b + c + d + e + f + g + h
}

fn clamp(x int, lo int, hi int) int {
    if x < lo {
        return lo
    } else if x > hi {
        return hi
    }
    return x
}

fn print_str(s string) {
    C.puts(s.str)
}

fn print_int(n int) {
    C.printf(c'%d\n', n)
}

fn main() {
    // 1. Basic arithmetic
    x := 10
    y := 20
    z := add(x, y)

    if z > 25 {
        print_str('big')
    } else {
        print_str('small')
    }

    // 2. For loop with sum
    mut sum := 0
    for i := 0; i < 5; i++ {
        sum = sum + i
    }
    if sum == 10 {
        print_str('sum ok')
    }

    // 3. Struct and method
    p := Point{
        x: 3
        y: 4
    }
    ps := p.sum()
    if ps == 7 {
        print_str('struct ok')
    }

    // 4. While loop
    mut count := 3
    for count > 0 {
        count = count - 1
    }
    if count == 0 {
        print_str('loop ok2')
    }

    // 5. Print the sum result
    print_int(z)

    // 6. Nested function calls
    result := add(multiply(3, 4), multiply(5, 6))
    if result == 42 {
        print_str('nested ok')
    }

    // 7. Multiple comparisons and boolean logic
    a := 15
    b := 25
    if a < b && b < 30 {
        print_str('logic ok')
    }

    if a == 15 || b == 99 {
        print_str('or ok')
    }

    // 8. Negation and abs
    neg := -42
    pos := abs(neg)
    if pos == 42 {
        print_str('abs ok')
    }

    // 9. Nested if/else
    val := 50
    if val < 0 {
        print_str('negative')
    } else if val == 0 {
        print_str('zero')
    } else if val < 100 {
        print_str('medium')
    } else {
        print_str('large')
    }

    // 10. Chained arithmetic
    chain := (10 + 20) * 3 - 5
    if chain == 85 {
        print_str('chain ok')
    }

    // 11. Bitwise operations
    bw := 0xFF & 0x0F
    if bw == 15 {
        print_str('bit and ok')
    }

    bw2 := 0xA0 | 0x05
    if bw2 == 0xA5 {
        print_str('bit or ok')
    }

    bw3 := 1 << 4
    if bw3 == 16 {
        print_str('shift ok')
    }

    // 12. Struct method returning struct
    p2 := Point{
        x: 2
        y: 3
    }
    p3 := p2.scale(10)
    if p3.x == 20 && p3.y == 30 {
        print_str('scale ok')
    }

    // 13. Nested struct
    r := Rect{
        origin: Point{
            x: 1
            y: 2
        }
        width:  10
        height: 5
    }
    if r.area() == 50 {
        print_str('rect ok')
    }
    if r.origin.x == 1 && r.origin.y == 2 {
        print_str('nested struct ok')
    }

    // 14. Fibonacci
    fib := fibonacci(10)
    if fib == 55 {
        print_str('fib ok')
    }

    // 15. Max function
    m := max(33, 77)
    if m == 77 {
        print_str('max ok')
    }

    // 16. Multiple mutable updates
    mut acc := 1
    for j := 1; j <= 5; j++ {
        acc = acc * j
    }
    if acc == 120 {
        print_str('factorial ok')
    }

    // 17. Comparison operators
    if 10 >= 10 {
        print_str('ge ok')
    }
    if 9 <= 10 {
        print_str('le ok')
    }
    if 10 != 11 {
        print_str('ne ok')
    }

    // 18. Modulo
    rem := 17 % 5
    if rem == 2 {
        print_str('mod ok')
    }

    // 19. Mutable struct fields
    mut mp := Point{
        x: 10
        y: 20
    }
    mp.x = 100
    mp.y = mp.x + 50
    if mp.x == 100 && mp.y == 150 {
        print_str('mut struct ok')
    }

    // 20. Division
    div := 100 / 3
    if div == 33 {
        print_str('div ok')
    }

    // 21. Enum values
    c1 := Color.red
    c2 := Color.blue
    if int(c1) == 0 && int(c2) == 2 {
        print_str('enum ok')
    }

    // 22. Enum in function
    name := color_name(Color.green)
    C.printf(c'color: %s\n', name.str)

    // 23. Bool return value
    if is_even(42) {
        print_str('even ok')
    }
    if !is_even(7) {
        print_str('odd ok')
    }

    // 24. Nested loops
    mut total := 0
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            total = total + 1
        }
    }
    if total == 12 {
        print_str('nested loops ok')
    }

    // 25. Break in loop
    mut found := -1
    for i := 0; i < 100; i++ {
        if i * i > 50 {
            found = i
            break
        }
    }
    if found == 8 {
        print_str('break ok')
    }

    // 26. Continue in loop
    mut odd_sum := 0
    for i := 0; i < 10; i++ {
        if is_even(i) {
            continue
        }
        odd_sum = odd_sum + i
    }
    if odd_sum == 25 {
        print_str('continue ok')
    }

    // 27. Enum as direction
    dx := direction_dx(Direction.right)
    dy := direction_dy(Direction.down)
    if dx == 1 && dy == 1 {
        print_str('direction ok')
    }

    // 28. Compound assignment operators
    mut ca := 10
    ca += 5
    ca -= 3
    ca *= 2
    if ca == 24 {
        print_str('compound ok')
    }

    // 29. XOR
    xr := 0xFF ^ 0x0F
    if xr == 0xF0 {
        print_str('xor ok')
    }

    // 30. Right shift
    rs := 256 >> 3
    if rs == 32 {
        print_str('rshift ok')
    }

    // 31. Collatz conjecture (complex loop logic)
    steps := collatz_steps(27)
    if steps == 111 {
        print_str('collatz ok')
    }

    // 32. count_even (function call in loop condition body)
    ev := count_even(10)
    if ev == 5 {
        print_str('count ok')
    }

    // 33. Struct with zero fields
    origin := Point{}
    if origin.x == 0 && origin.y == 0 {
        print_str('zero struct ok')
    }

    // 34. Multiple early returns
    m2 := max(max(10, 20), max(15, 5))
    if m2 == 20 {
        print_str('multi ret ok')
    }

    // 35. sum_range
    sr := sum_range(1, 11)
    if sr == 55 {
        print_str('range sum ok')
    }

    // 36. Recursive fibonacci
    rf := fib_recursive(10)
    if rf == 55 {
        print_str('rec fib ok')
    }

    // 37. Recursive factorial
    fact := factorial_recursive(6)
    if fact == 720 {
        print_str('rec fact ok')
    }

    // 38. GCD
    g := gcd(48, 18)
    if g == 6 {
        print_str('gcd ok')
    }

    // 39. Power
    pw := power(2, 10)
    if pw == 1024 {
        print_str('power ok')
    }

    // 40. Heap allocation (&Point{})
    hp := &Point{
        x: 42
        y: 84
    }
    if hp.x == 42 && hp.y == 84 {
        print_str('heap ok')
    }

    // 41. Mut struct parameter (swap)
    mut sp := Point{
        x: 10
        y: 20
    }
    swap_point(mut sp)
    if sp.x == 20 && sp.y == 10 {
        print_str('swap ok')
    }

    // 42. Mut struct parameter (scale)
    mut sc := Point{
        x: 5
        y: 3
    }
    scale_point(mut sc, 10)
    if sc.x == 50 && sc.y == 30 {
        print_str('mut param ok')
    }

    // 43. Nested return (all branches return)
    nr1 := nested_return(5)
    nr2 := nested_return(15)
    nr3 := nested_return(25)
    if nr1 == 100 && nr2 == 200 && nr3 == 300 {
        print_str('nested ret ok')
    }

    // 44. Global variable
    g_val = 100
    g_val += 50
    g_val -= 20
    if g_val == 130 {
        print_str('global ok')
    }

    // 45. Many arguments (8 args)
    sm := sum_many(1, 2, 3, 4, 5, 6, 7, 8)
    if sm == 36 {
        print_str('8 args ok')
    }

    // 46. Infinite loop with break
    mut inf := 0
    for {
        inf++
        if inf == 10 {
            break
        }
    }
    if inf == 10 {
        print_str('inf loop ok')
    }

    // 47. Assert
    assert 2 + 2 == 4
    assert 10 > 5
    print_str('assert ok')

    // 48. Double negation
    dn := !!true
    if dn {
        print_str('double neg ok')
    }

    // 49. Clamp
    cl1 := clamp(5, 0, 10)
    cl2 := clamp(-5, 0, 10)
    cl3 := clamp(15, 0, 10)
    if cl1 == 5 && cl2 == 0 && cl3 == 10 {
        print_str('clamp ok')
    }

    // 50. Heap struct method call
    hp2 := &Point{
        x: 7
        y: 8
    }
    hs := hp2.sum()
    if hs == 15 {
        print_str('heap method ok')
    }
}