module: CommonTasks
    function: add_numbers

        body:
            return num1 + num2
        end body

        parameter:

           declare num1: int
           declare num2: int

        return_type: int

    end function
end module

module: MathUtils
    function: square_number
        parameter:
            declare number: int
        return_type: int
        body:
            return number * number
        end body
    end function
end module

module: StringUtils
    function: concatenate
        parameter:
            declare first_str: string
            declare second_str: string
        return_type: string
        body:
            return first_str + second_str
        end body
    end function
end module

module: MainModule
    import: CommonTasks, MathUtils, StringUtils, BuiltinUtils


    function: test
        parameter:
            declare first_str: string
            declare second_str: string
        return_type: string
        body:
            return first_str + second_str
        end body
    end function

    function: main
    parameter:
        declare args: string
    return_type: void
    body:
        declare input_number: int = BuiltinUtils.to_int(args)

        if input_number <= 0 then
            input_number = 5
        end if

        loop:
            initializer:
                declare i: int = 0
            condition:
                i < input_number
            update:
                i = i + 1
            body:
                if i % 2 == 0 then
                    BuiltinUtils.print("i is even: " + BuiltinUtils.to_string(i))

                    if i > 2 then
                        BuiltinUtils.print("i is greater than 2")

                        loop:
                            initializer:
                                declare k: int = 0
                            condition:
                                k < 3
                            update:
                                k = k + 1
                            body:
                                BuiltinUtils.print("k = " + BuiltinUtils.to_string(k))

                                if k == 2 then
                                    BuiltinUtils.print("k is two")

                                    loop:
                                        initializer:
                                            declare n: int = 0
                                        condition:
                                            n < 2
                                        update:
                                            n = n + 1
                                        body:
                                            BuiltinUtils.print("n = " + BuiltinUtils.to_string(n))

                                            if n == 1 then
                                                BuiltinUtils.print("n is one")

                                                if i > 3 then
                                                    BuiltinUtils.print("deep i > 3 block")

                                                    loop:
                                                        initializer:
                                                            declare x: int = 0
                                                        condition:
                                                            x < 2
                                                        update:
                                                            x = x + 1
                                                        body:
                                                            if x == 1 then
                                                                BuiltinUtils.print("x is one at depth")
                                                            else
                                                                BuiltinUtils.print("x is zero at depth")
                                                            end if
                                                        end body
                                                    end loop
                                                end if
                                            end if
                                        end body
                                    end loop
                                end if
                            end body
                        end loop
                    end if

                else
                    BuiltinUtils.print("i is odd: " + BuiltinUtils.to_string(i))

                    loop:
                        initializer:
                            declare j: int = 0
                        condition:
                            j < i
                        update:
                            j = j + 1
                        body:
                            if j == 1 then
                                BuiltinUtils.print("first inner")
                            else
                                if j % 2 == 0 then
                                    BuiltinUtils.print("j even")

                                    if j > 2 then
                                        BuiltinUtils.print("j > 2, deeper if")

                                        loop:
                                            initializer:
                                                declare y: int = 0
                                            condition:
                                                y < 2
                                            update:
                                                y = y + 1
                                            body:
                                                BuiltinUtils.print("y in deep even j loop: " + BuiltinUtils.to_string(y))
                                                if y == 1 then
                                                    BuiltinUtils.print("y is one")
                                                end if
                                            end body
                                        end loop
                                    end if

                                else
                                    BuiltinUtils.print("j odd")

                                    loop:
                                        initializer:
                                            declare m: int = 0
                                        condition:
                                            m < 2
                                        update:
                                            m = m + 1
                                        body:
                                            BuiltinUtils.print("m = " + BuiltinUtils.to_string(m))

                                            if m == 1 then
                                                BuiltinUtils.print("m is one")

                                                if j > 3 then
                                                    BuiltinUtils.print("j > 3, going deeper")

                                                    loop:
                                                        initializer:
                                                            declare z: int = 0
                                                        condition:
                                                            z < 2
                                                        update:
                                                            z = z + 1
                                                        body:
                                                            BuiltinUtils.print("z = " + BuiltinUtils.to_string(z))
                                                        end body
                                                    end loop
                                                end if
                                            end if
                                        end body
                                    end loop
                                end if
                            end if
                        end body
                    end loop
                end if

                declare sum: int = CommonTasks.add_numbers(i, 10)
                declare squared: int = MathUtils.square_number(sum)
                BuiltinUtils.print("i+10 squared = " + BuiltinUtils.to_string(squared))
            end body
        end loop

        declare final_message: string = StringUtils.concatenate("Finished with input: ", BuiltinUtils.to_string(input_number))
        BuiltinUtils.print(final_message)
    end body
    end function




end module