//! Encapsulate state in components
use dioxus::prelude::*;

#[component]
fn Stateful(name: String, age: u64) -> Element {
    rsx! {"Hello {name}, you are {age} years old!"}
}

fn App() -> Element {
    rsx! { Stateful { name: "Alice", age: 30 } }
}

//! Easily integrate async Rust code into your components.
use dioxus::prelude::*;

fn Tasks() -> Element {
    let mut count = use_signal(|| 0);

    use_future(move || async move {
        loop {
            count += 1;
            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
        }
    });

    rsx! { pre { "Count: {count}" } }
}

//! Server functions let you write server-side code that can be called from the client as a normal async function.
use dioxus::prelude::*;

#[component]
fn Server() -> Element {
    let future = use_server_future(get_server_data)?;

    match future() {
        Some(Ok(data)) => rsx! { pre { "The server says: {data}" } },
        Some(Err(e)) => rsx! {"An error occurred: {e:?}"},
        None => rsx! {"Loading..."},
    }
}

#[server]
async fn get_server_data() -> Result<String, ServerFnError> {
    Ok("Hello from the server!".to_string())
}

//! Use Signal::global to easily manage global state with a simple Atom-based API
use dioxus::prelude::*;

// Define an atom of state
static COUNT: GlobalSignal<i32> = Signal::global(|| 0);

// Read it anywhere
fn Read() -> Element {
    rsx! {"Count: {COUNT}"}
}

// Or write to it from anywhere
fn Increment() -> Element {
    rsx! { button { onclick: move |_| *COUNT.write() += 1, "Increment" } }
}

fn App() -> Element {
    rsx! {
        Read {}
        Increment {}
    }
}