use boa_engine::Context;

fn main() {
    let js_code = "console.log('Hello World from a JS code string!')";

    // Instantiate the execution context
    let mut context = Context::default();

    // Parse the source code
    match context.eval(js_code) {
        Ok(res) => {
            println!("{}", res.to_string(&mut context).unwrap());
        }
        Err(e) => {
            // Pretty print the error
            eprintln!("Uncaught {}", e.display());
        }
    };
}

use boa_engine::{builtins::JsArgs, Context, JsResult, JsValue};

/// Says "hello" using the first argument.
fn say_hello(_this: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
    let name = args.get_or_undefined(0);

    if name.is_undefined() {
        println!("Hello World!");
    } else {
        println!("Hello {}!", name.to_string(context)?);
    }

    Ok(JsValue::undefined())
}

context.register_global_builtin_function("say_hello", 1, say_hello);

let js_code = r#"say_hello("Rust");"#;

use boa_engine::property::Attribute;

context.register_global_property("MY_PROJECT_VERSION", "1.0.0", Attribute::all());

say_hello(MY_PROJECT_VERSION);

use boa_gc::{Finalize, Trace};

#[derive(Debug, Trace, Finalize)]
struct Person {
    /// The name of the person.
    name: String,
    /// The age of the person.
    age: u8,
}

impl Person {
    /// Says "hello" using the name and the age of a `Person`.
    fn say_hello(this: &JsValue, _args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
        let this = this
            .as_object()
            .and_then(|obj| obj.downcast_ref::<Self>())
            .ok_or_else(|| context.construct_type_error("`this` is not a `Person` object"))?;

        println!("Hello {}-year-old {}!", this.age, this.name);

        Ok(JsValue::undefined())
    }
}

use boa_engine::{
    builtins::JsArgs,
    class::{Class, ClassBuilder},
};

impl Class for Person {
    const NAME: &'static str = "Person";
    const LENGTH: usize = 2;

    // This is what is called when we construct a `Person` with the expression `new Person()`.
    fn constructor(_this: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<Self> {
        let name = args.get_or_undefined(0).to_string(context)?;
        let age = args.get_or_undefined(1).to_u32(context)?;

        if !(0..=150).contains(&age) {
            context.throw_range_error(format!("invalid age `{age}`. Must be between 0 and 150"))?;
        }

        let age = u8::try_from(age).expect("we already checked that it was in range");

        let person = Person {
            name: name.to_string(),
            age,
        };

        Ok(person)
    }

    /// Here is where the class is initialized, to be inserted into the global object.
    fn init(class: &mut ClassBuilder) -> JsResult<()> {
        class.method("say_hello", 0, Self::say_hello);

        Ok(())
    }
}

context
    .register_global_class::<Person>()
    .expect("could not register class");

let person = new Person("John", 28);
person.say_hello();

use boa_engine::{
    builtins::JsArgs, object::JsArray, property::Attribute, Context, JsResult, JsValue,
};

/// Reverses an array and appends the `"My Project"` string and the `MY_PROJECT_VERSION` global
/// property to it.
fn reverse_append(_this: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
    let arr = args
        .get_or_undefined(0)
        .as_object()
        .ok_or_else(|| context.construct_type_error("argument must be an array"))?;

    let arr = JsArray::from_object(arr.clone(), context)?;

    let reverse = arr.reverse(context)?;
    reverse.push("My Project", context)?;

    let global_object = context.global_object().clone();
    let version = global_object
        .get("MY_PROJECT_VERSION", context)
        .unwrap_or_default();

    reverse.push(version, context)?;

    Ok((*reverse).clone().into())
}

fn main() {
    let js_code = r#"
        let arr = ['a', 2, 5.4, "Hello"];
        reverseAppend(arr);
    "#;

    // Instantiate the execution context
    let mut context = Context::default();

    context.register_global_property("MY_PROJECT_VERSION", "1.0.0", Attribute::all());

    context.register_global_builtin_function("reverseAppend", 1, reverse_append);

    // Parse the source code
    match context.eval(js_code) {
        Ok(res) => {
            println!("{}", res.to_string(&mut context).unwrap());
        }
        Err(e) => {
            // Pretty print the error
            eprintln!("Uncaught {}", e.display());
        }
    };
}

use boa_derive::TryFromJs;
use boa_engine::{value::TryFromJs, Context, JsResult, JsValue};

#[derive(Debug, TryFromJs)]
#[allow(dead_code)]
struct TestStruct {
    inner: bool,
    hello: String,
    #[boa(from_js_with = "lossy_conversion", hello = "myfriend")]
    my_float: i16,
}

fn main() {
    let js = r#"
    let x = {
        inner: false,
        hello: "World",
        my_float: 2.9,
    };

    x;
    "#;

    let mut context = Context::default();
    let res = context.eval(js).unwrap();

    let str = TestStruct::try_from_js(&res, &mut context)
        .map_err(|e| e.display().to_string())
        .unwrap();

    println!("{str:?}");
}

/// Converts the value lossly
fn lossy_conversion(value: &JsValue, context: &mut Context) -> JsResult<i16> {
    match value {
        JsValue::Rational(r) => Ok(r.round() as i16),
        JsValue::Integer(i) => Ok(*i as i16),
        _ => context.throw_type_error("cannot convert value to an i16"),
    }
}