import "fmt";
import "strings";

// structs are plain data
struct Point {
    x: float;
    y: float;
}

// classes have fields and methods
class Animal {
    name: string;
    age: int;

    fn speak() -> string {
        return "...";
    }

    fn describe() -> string {
        return "I am " + self.name;
    }
}

class Dog {
    name: string;
    age: int;

    fn speak() -> string {
        return "Woof!";
    }

    fn fetch(item: string) -> string {
        return self.name + " fetched the " + item;
    }
}

// basic function
fn add(a: int, b: int) -> int {
    return a + b;
}

// optional return type
fn find(name: string) -> string? {
    if name == "mist" {
        return name;
    }
    return null;
}

// array types
fn sum(numbers: [int]) -> int {
    let total: int = 0;
    for n in numbers {
        total = total + n;
    }
    return total;
}

// multiple params, no return
fn greet(first: string, last: string) {
    let full: string = first + " " + last;
    print(full);
}

// structs initialized with fields
fn make_point(x: float, y: float) -> Point {
    return Point {
        x: x,
        y: y,
    };
}

// if / else
fn classify(n: int) -> string {
    if n < 0 {
        return "negative";
    } else {
        return "positive";
    }
}

// entry point
fn main() {
    // variables
    let x: int = 10;
    let y: int = 20;
    let result: int = add(x, y);

    // inferred (no type annotation)
    let message = "Hello from Mist!";
    print(message);

    // struct usage
    let p: Point = make_point(1.5, 2.5);
    print(p.x);

    // class usage
    let dog: Dog = Dog {
        name: "Rex",
        age: 3,
    };
    print(dog.speak());
    print(dog.fetch("ball"));

    // arrays
    let nums: [int] = [1, 2, 3, 4, 5];
    let total: int = sum(nums);
    print(total);

    // for loop
    for n in nums {
        print(n);
    }

    // optional
    let found: string? = find("mist");
    if found {
        print(found);
    }
}