// moto script v2.0
// moto scripts are written in a simple language that is easy to understand and write
// a moto script is broken down into a collection of cells. cells are the basic building blocks of a moto script
// a cell can be a package,runtime or a task
// a task is a sequence of commands that are executed in order one line at a time using the runtime specified at its tail
// for example `task some_task{ echo "hello world" }:ps` is a task cell. the tail of the cell is `:ps` which specifies the runtime to be used for executing the task
task greet {
    echo "hello world"
}:ps

// tasks can be defined in any runtime , provided the runtime's definition is available to the moto runtime
// let's define a task in the dart runtime
task greet_from_dart {
    print("hello world");
}:dart

// the above task will be executed using the dart runtime.
// however, for this to work, we should define the dart runtime in the script like below
runtime dart {
    // the definition of the dart runtime
    // runtimes are a collection of tasks that are required to handle execution of its dependent tasks
    // for example, the dart runtime should have a task that can execute a dart script
    // this is always 'run' task
    // notice that the task itself has a tail that specifies the runtime to be used for executing that particular task

    task run {
        # inside a task you can write any code that you want to run in the language of the runtime
        # for example here the code is written in powershell. that is why
        $something = @'[:block]'@
        $something | Out-File -FilePath "./_.dart" -Encoding UTF8
        dart run "./_.dart"
    }:ps

    // a runtime can have any number of tasks
    // for example, the dart runtime can have a task that can compile a dart script to a binary
    task compile {
        something = @'[:block]'@
        something | Out-File -FilePath "./_.dart" -Encoding UTF8
        dart compile "./_.dart" --output="./_.exe" 
    }:ps

    // the above task can be invoked on greeting_from_dart task by calling `[:greet_from_dart(compile)]`
    // similarly, the run task can be invoked on greeting_from_dart task by calling `[:greet_from_dart(run)]`
    // since `run` is the default task for the dart runtime, we can also call `[:greet_from_dart()]` and it will be executed using the `run` task
    // we dont need to specify the runtime for the task to be executed as runtime for execution of a task is defined in the task itself (the tail of the task)

}:moto // the runtime is defined in moto language (the code inside the curly braces is written in moto language)



// Global Variables Documentation
// Moto scripts support global variables which are accessible from any part of the script, regardless of the runtime.
// Variables are declared using the 'let' command and can be used within tasks by enclosing the variable name in '[: ]'.
// Example: Declaring and using a global variable
let greeting = "Hello from Moto";
task useGlobalVariable {
    echo "[:greeting]"; # Outputs: Hello from Moto
}:ps

// Task Execution with Global Variables
// Tasks can seamlessly use global variables, simplifying data sharing between different parts of the script.
// This feature enables dynamic task execution based on globally shared state or configurations.

// Best Practices for Task and Variable Management
// - Use clear, descriptive names for tasks and variables.
// - Minimize the use of global variables to reduce side effects and improve script readability.
// - Organize related tasks into packages or runtime groups for better maintainability.


// a package is a collection of cells
// a package can be used to group related cells together,use them in a particular fashion or to share them with others
// a package can be imported into another package or script using the `import` command (in moto language)
// eg: `use dart from "./dart.moto"` will import the dart package from the file `dart.moto` into the current package or script
package rust {
    // a package can contain any number of cells
    // for example, a package can contain a runtime
    runtime rust {
        // the definition of the rust runtime
        // runtimes are a collection of tasks that are required to handle execution of its dependent tasks
        // for example, the rust runtime should have a task that can execute a rust script
        // this is always 'run' task
        // notice that the task itself has a tail that specifies the runtime to be used for executing that particular task

        task run {
            # inside a task you can write any code that you want to run in the language of the runtime
            # for example here the code is written in powershell. that is why
            $something = @'[:block]'@
            $something | Out-File -FilePath "./_.rs" -Encoding UTF8
            rustc "./_.rs" -o "./_.exe"
            "./_.exe"
        }:ps

        // a runtime can have any number of tasks
        // for example, the rust runtime can have a task that can compile a rust script to a binary
        task compile {
            something = @'[:block]'@
            something | Out-File -FilePath "./_.rs" -Encoding UTF8
            rustc "./_.rs" -o "./_.exe"
        }:ps

        // the above task can be invoked on greeting_from_dart task by calling `[:greet_from_dart(compile)]`
        // similarly, the run task can be invoked on greeting_from_dart task by calling `[:greet_from_dart(run)]`
        // since `run` is the default task for the rust runtime, we can also call `[:greet_from_dart()]` and it will be executed using the `run` task
        // we dont need to specify the runtime for the task to be executed as runtime for execution of a task is defined in the task itself (the tail of the task)

    }:moto // the runtime is defined in moto language (the code inside the curly braces is written in moto language)

    // more about moto language
    // moto language is a simple language that is easy to understand and write
    // other than the cells, the moto language has a few commands that fecilitate manipulation of cells and their execution
    // in hopes of avoiding ambiguity, these commands end with a `;`
    // they are as follows:
    // 1. import -
    //    use command is used to import a package into the current package or script
    //    eg: `import math as m` will import the package `math` from the file `math.moto` into the current package or script and it can be accessed using the alias `m`
    //    aliases are optional and if not provided, the package will be imported and in an exposed state. that is, the cells of the imported package can be accessed directly
    //    eg: `import math` will import the package `math` from the file `math.moto` such taht we can call `[:pi]` directly. if we use an alias, we will have to call `[:m:pi]`
    import math as m;
    // 2. let -
    //    let command is used to define a variable in the current package or script
    //    eg: `let x = 10;` will define a variable `x` with value `10`
    //    variables can be used anywhere in the script (in any language) using the `[:variable_name]` syntax
    //    eg: `echo "[:x]"` will print `10` even if the echo command is written in a different runtime (powershell in this case)
    //    moto has support for all the basic data types like string `"some string"`, number `10`, boolean `true` and `false` arrays `["a","b","c"]` objects `{a:10,b:"hello",c:true}` and null `null`
    //    let commands are mostly used to support configuration of the script or to share values between different runtimes
    let version = "1.0.0";


    // packages are often used to group more functionalities like installing runtime dependencies (eg: installing rust sdk itself into the host machine)
    task install {
        wget "https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe" -OutFile "rustup-init.exe"
        .\rustup-init.exe -y
        $env:Path += ";C:\Users\runneradmin\.cargo\bin"
    }:ps

    // the above task can be invoked by calling `[:install()]` within the package or `[:rust:install()]` from outside the package
    // notice that we cannot call compile or run tasks from outside the package as they are not defined in the package itself
    // only direct children of the package can be accessed from outside the package. we can access runtime from outside the package as it is a direct child of the package
    // if we `import rust as r` then we can access the install task as `[:r:install()]` and the run task as `[:r:run()]` and so on
    // similarly, in tails we would have to use `:r:rust` instead of `:rust` and so on. for this reason, it is often a good practice to not use aliases for packages
    // if we dont use aliases, we can access the cells of the package directly. for example, we can access the install task as `[:install()]` and the run task as `[:run()]` and so on
    // similarly, in tails we can use `:rust` instead of `:r:rust` which is more readable and less error prone


}:moto // the package is defined in moto language (the code inside the curly braces is written in moto language)