/// recursive function calls to compute n-th
/// fibonacci sequence number

fn fib(n: int) -> int {
    if n <= 1 {
        return n;
    }

    return fib(n - 2) + fib(n - 1);
}

let nums = vec<int>[];
for let mut i = 0; i < 30; i += 1 {
    nums.push(fib(i));
}

/// sorting a vector using
/// insertion sort

fn insertion_sort(input: vec<int>) {
    for let mut i = 1; i < input.len(); i += 1 {
        let cur = input[i];
        let mut j = i - 1;
    
        while input[j] > cur {
            let temp = input[j + 1];
            input[j + 1] = input[j];
            input[j] = temp;
      
            if j == 0 {
              break;
            }
    
            j -= 1;
        }
    }
}

let input: vec<int> = vec[4, 13, 0, 3, -3, 4, 19, 1];

insertion_sort(input);

println(input); // [vec] [-3, 0, 1, 3, 4, 4, 13, 19]

/// structs

struct Circle {                 // struct declaration
    radius: float,
    center: Point,
    tangents: vec<Tangent>,     // inner vector of structs
}

impl Circle {                   // struct implementation
    fn calc_area() -> float {
        return PI * self.radius * self.radius;
    }
  
    fn add_tangent(t: Tangent) {      
        self.tangents.push(t);
    }
}

struct Point {
    x: int,
    y: int,
}

struct Tangent {
    p: Point,
}

const PI = 3.14159;

let circle = Circle {     // struct instantiation
    radius: 103.5,
    center: Point { x: 1, y: 5 } ,             // inner structs instantiation
    tangents: vec[                             // inner vector of structs instantiation
        Tangent { p: Point { x: 4, y: 3 } },
        Tangent { p: Point { x: 1, y: 0 } },
    ],
};

let area = circle.calc_area();  // 33653.4974775

circle.add_tangent(
    Tangent { p: Point { x: 11, y: 4 } }  // third tangent added
);

/// first-class functions

let make_adder = fn (x: num) -> func {
    return fn (y: num) -> num {
        return x + y;
    };
};

let add5 = make_adder(5);
let add7 = make_adder(7);

println(add5(2)); // 7
println(add7(2)); // 9

/// compute the greatest common divisor 
/// of two integers using Euclids algorithm

fn gcd(mut n: int, mut m: int) -> int {
    while m != 0 {
        if m < n {
            let t = m;
            m = n;
            n = t;
        }
        m = m % n;
    }

    return n;
}

gcd(15, 5); // 5

let x: int;

let mut y: str = "hello" + " world";

let double: func = fn (x: num) -> num {
    return x * 2;
};

let human: Person = Person { name: "Jane" };

let names: vec<str> = vec["Josh", "Carol", "Steven"];

let x = true || false; // inferred as "bool";

let mut y;
y = vec<bool>[]; // inferred as "vec<bool>";

let dog;
dog = Dog { name: "Good Boy"}; // inferred as "Dog";

let mut s: str = "string";
s = vec[]; //! type error

let mut a: any = Rectangle { height: 10, width: 10 };
a.height = "string"; //! type error
a = 45.34; // valid

let x: str = "string";

let y: num;
y = 100;

let mut x: str = "hello";
x += " world";
x += "another string";

let x: int = 100;
let x: str = "This was x value before: " + x;
let x: vec<any> = vec[];

if x >= 100 {
    println("x is more than 100");
} else if x <= 100 && x > 0 {
    println("x is less than 100, but positive");
} else {
    println("x a non-positive number");
}

let direction = match get_direction() {
    "north" => 0,
    "east" => 90,
    "south" => 180,
    "west" => 270,
};

let age = 40;

let description: str = match true {
    age > 19 => "adult",
    age >= 13 && x <= 19 => "teenager",
    age < 13 => "kid",
};

while x != 100 {
    x += 1;
}

loop {
    i -= 1;
    x[i] *= 2;
    if x.len() == 0 {
        break;
    }
}

for let mut i = 0; i < v.len(); i += 1 {
    println(v[i]);
}

// the first or the last parts can be omitted
let mut i = 0;

for ; i < v.len(); {
    println(v[i]);
    i += 0;
}

// or all three of them
// this is basically "while true" or "loop"
let mut i = 0;

for ;; {
    println(v[i]);
    i -= 1;

    if i < v.len() {
        break;
    }
}

fn add(x: num, y: num) -> num {
    return x + y;
}

let sum = add(1, 100); // 101

fn clone(c: Circle) -> Circle {
    return Circle {
        radius: c.radius,
        center: c.center,
        tangents: vec<Tangent>[],
    };
}

let cloned = clone(circle);

// since this function returns nothing, the return type can be omitted
fn log(level: str, msg: str) {
    println("Level: " + level + ", message: " + msg);
}

/// function returns closure
/// which captures the internal value i
/// each call to the closure increments the captured value
fn create_counter() -> func {
    let mut i = 0;

    return fn () {
        i += 1;
        println(i);
    };
}

let counter: func = create_counter();

counter(); // 1
counter(); // 2
counter(); // 3

fn vec_concat(prefix: str, suffix: str) -> str {
    return prefix + suffix;
}

fn str_transform(callable: func, a: str, b: str) -> any {
    return callable(s1, s2);
}

str_transform(str_concat, "hello", " world");

fn inc(mut x: int) -> int {
    x += 1;
    return x;
}

// same as with shadowing
fn inc(x: int) -> int {
    let mut x = x;
    x += 1;
    return x;
}

(fn (names: vec<str>) {
    for let mut i = 0; i <= names.len(); i += 1 {
        println(names[i]);
    }
})(vec["Rob", "Sansa", "Arya", "Jon"]);

struct Person {
    name: str,          // property of type str
    country: Country,   // property of type struct Country
    alive: bool,
    pets: vec<Animal>,  // property of type vector of structs Animal
}

struct Animal {
    kind: str,
    alive: bool,
}

struct Country {
    name: str,
}

impl Person {
    fn change_name(new_name: str) {
        self.name = new_name;
    }
  
    fn clone() -> Person {
        return Person {
            name: self.name,
            country: self.country,
            alive: self.alive,
            pets: self.pets,
        };
    }
}

let cat = Animal {
    kind: "cat",
    alive: true
};

let john: Person = Person {
    name: "John",
    alive: true,
    pets: vec[cat],                    // via variable
    country: Country { name: "UK" }    // via inlined struct instantiation
};

// set new value
john.country = Country { name: "USA" };
john.pets.push( Animal {
    kind: "dog",
    alive: true
});

// get value
println(john.pet[0].kind); // cat

// call method
let cloned = john.clone();
cloned.change_name("Jonathan");

john.name = "Steven";    // valid, John is not a John anymore
john.pet.kind = "dog"    // also valid, john's pet is changed
john = Person { .. };    // invalid, "john" cannot point to another struct

fn kill(person: Person) {
    person.alive = false;     // oh, john is dead
    person.pet.alive = false; // as well as its pet. RIP
}

kill(john);

let planets = vec<str>["Mercury", "Venus", "Earth", "Mars"];

let mars = planets[3];

planents.push("Jupiter");     // "Jupiter" is now the last value in a vector

let jupiter = planets.pop(); // "Jupiter" is no longer in a vector.

planets[2] = "Uranus";       // "Earth" is gone. "Uranus" is on its place now

planets.len();               // 3

typeof(planets);             // vec<str>

let v: vec = vec[];                     // typeof(v) = vec<any>
let v = vec[];                          // typeof(v) = vec<any>

let v: vec<int> = vec[1, 2, 3];         // typeof(v) = vec<int>
let v = vec<int>[1, 2, 3];              // typeof(v) = vec<int>
let v = vec[1, 2, 3];                   // typeof(v) = vec<int>, because all the initial values are of type "int"

let v = vec<bool>[true];                // typeof(v) = vec<bool>

let v: vec<Dog> = vec[                  // typeof(v) = vec<Dog>, type declaration can actually be omitted
    Dog { name: "dog1" },
    Dog { name: "dog2" },
];

let v = vec[                            // typeof(v) = vec<vec<Point>,
    vec[                                // inferred by the initial values, despite the type being omitted
        Point { x: 1, y: 1 }, 
        Point { x: 0, y: 3 } 
    ],
    vec[ 
        Point { x: 5, y: 2 }, 
        Point { x: 3, y: 4 } 
    ],
];


let matrix = vec[                       // typeof(v) = vec<vec<int>>
    vec[1, 2, 3, 4, 5],
    vec[3, 4, 5, 6, 7],
    vec[3, 4, 5, 6, 7],
];

let things = vec[nil, false, Dog {}];   // typeof(v) = vec<any>

let animals: vec = vec[
    Elephant { name: "Samuel" },
    Zebra { name: "Robert" },
    WolfPack { 
        wolves: vec<Wolf>[
            Wolf { name: "Joe" },
            Wolf { name: "Mag" },
        ]
    }
]

let mag = animals[2].wolves[1]; // Mag

const MESSAGE = "hello world";

const PI = 3.14159;

const E = 2.71828;

// inline comments

/*
    multiline comment
 */

let x = 100; /* inlined multiline comment */ let y = x;