fn main() {
    let a  = ["hi";100];

    if a.len() >= 100 {
        println!("Wow, that's a big array!");
    } else {
        println!("Meh, I eat arrays like that for breakfast.");
    }
}

#[test]
fn slice_out_of_array() {
    let a = [1, 2, 3, 4, 5];
    let nice_slice = &a[1..4];
    assert_eq!([2, 3, 4], nice_slice)
}

    let a = [10, 20, 30, 40]; // a plain array
    let v : Vec<i32>= vec![10,20,30,40];


fn vec_loop(mut v: Vec<i32>) -> Vec<i32> {
    for i in v.iter_mut() {
        // TODO: Fill this up so that each element in the Vec `v` is
        // multiplied by 2.
        *i = *i * 2;
    }

    // At this point, `v` should be equal to [4, 8, 12, 16, 20].
    v
}

fn vec_map(v: &Vec<i32>) -> Vec<i32> {
    v.iter().map(|num| {
        // TODO: Do the same thing as above - but instead of mutating the
        // Vec, you can just return the new number!
        num * 2
    }).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_vec_loop() {
        let v: Vec<i32> = (1..).filter(|x| x % 2 == 0).take(5).collect();
        let ans = vec_loop(v.clone());

        assert_eq!(ans, v.iter().map(|x| x * 2).collect::<Vec<i32>>());
    }

    #[test]
    fn test_vec_map() {
        let v: Vec<i32> = (1..).filter(|x| x % 2 == 0).take(5).collect();
        let ans = vec_map(&v);

        assert_eq!(ans, v.iter().map(|x| x * 2).collect::<Vec<i32>>());
    }
}

struct ColorClassicStruct {
    // TODO: Something goes here
    red : i32 ,
    green : i32,
    blue : i32,
}

struct ColorTupleStruct(i32,i32,i32);

struct UnitLikeStruct;

// TODO: Instantiate a classic c struct!
let green = ColorClassicStruct{red: 0, green: 255, blue: 0};
// TODO: Instantiate a tuple struct!
let green = ColorTupleStruct(0,255,0);
// TODO: Instantiate a unit-like struct!
let unit_like_struct = UnitLikeStruct;

enum Message {
    Echo(String), //Echo :: String -> Message
    Move {x: i32, y:i32}, // Move :: Struct{i32,i32} -> Message
    ChangeColor(i32,i32,i32), // ChangeColor :: Tuple(i32,i32,i32) -> Message
    Quit, // Quit :: Message
}

match Message{
    Message::Echo(p) => ...,
    Message::Move(s) => ...,
    Message::ChangeColor(a,b,c) =>...,
    Message::Quit => ...,
}

//method 1
if basket.get(&fruit) == None {
        basket.insert(fruit,11);
}
//method2
basket.entry(fruit).or_insert(0); //init if does not exist
basket.entry(fruit) += 11; //then modify

let message : any = "Hello World";
let messageA = "Hello World"; //same
//var message in vanilla JS

console.log(message);

//string type
let StringA : string;
StringA = "hello";
//number type
let numA : number;
numA = 4;
//boolean type
let boolA : boolean;
boolA = false;

//list functor
let arrStr : string[] = ['a','b','c'];
arrStr[0] = 'e';
arrStr.push('e');

//Coproduct
let coproductA : string | number;
coproductA = 4;
console.log(coproductA);
coproductA = "hi";
console.log(coproductA);

//list functor applied to coproduct
let listcoproduct : (string | number)[] = [1,"a",3];
console.log(listcoproduct);

//Product type
let dog = {
    name: "fido",
    age: 10
}
console.log(dog);

//type alias
type AnotherType = string | number;
let SomeObj : AnotherType;
SomeObj = 3;
SomeObj = "a";

//function
let mult = (x:number, y:number):number =>{
    return x * y;
}
console.log(mult(2,4));

let sum: (x:number, y:number) => number; //predeclare type

sum = (p:number,q: number) => {
    return p + q;
}
console.log(sum(2,4));

//generics or templates in C++
let somethn= <T>(x : T): T[] => {
    return [x,x];
}
console.log(somethn<string>("somethn"));
//another form
function somethn2<T>(x : T) : T[] {
    return [x,x];
}
console.log(somethn2<string>("somethn2"))

//Unit type function
const hey = () => {
    console.log("hey");
}
//Interface
interface CarInterface {
    model: string;
    year: number;
}

let somecar: CarInterface = {
    model : "Honda",
    year : 1996
}
//Class
class electricCar implements CarInterface {
    model : string;
    year : number;
    private msg : string;
    constructor(x: string, y : number, z : string){
        this.model = x;
        this.year = y; 
        this.msg = z;
    }
    outp = ():string => {
        return this.msg;
    }
}

let tesla = new electricCar("model E",2012,"Honk Honk")
console.log(tesla.outp());

//Typescript with HTML
//---------------------------------------------------------------------------mini project [START]
//hook html inputform to javascript, ! tells compiler it will not be empty
const inputform = document.querySelector('form')!;
console.log(inputform);

//get textbox text by the id
const modelxinput = document.querySelector('#modelid') as HTMLInputElement;
console.log(modelxinput); //<input type="text" name="modelx" id="modelid">
console.log(modelxinput.value); //outputs the textbox text

//change innerHTML of "someclass" class which is inside <div>
const someclassA = document.querySelector('.someclass') as HTMLDivElement;

inputform.addEventListener("submit", (msg) => {
    msg.preventDefault();
    someclassA.innerText = modelxinput.value;
    inputform.reset();
})

//---------------------------------------------------------------------------mini project [END]