pub fn main() {
    #[cfg(feature = "client")]
    wasm_bindgen_futures::spawn_local(async { client::app().await.unwrap() });

    #[cfg(feature = "server")]
    async_std::task::block_on(async { server::app().await.expect("") });
}

/// ===============================
///  Common code (shared types)
/// ===============================
#[derive(PartialEq, strum::EnumIter, strum::Display, strum::AsRefStr, strum::EnumString)]
pub enum SelectedStream {
    Football,
    Hockey,
    Socker,
}

/// Client-specific code
#[cfg(feature = "client")]
mod client {
    use super::*;
    use dioxus_core::prelude::*;
    use strum::IntoEnumIterator;

    pub async fn app() -> anyhow::Result<()> {
        Ok(dioxus_web::WebsysRenderer::start(APP).await)
    }

    static APP: FC<()> = |cx| {
        todo!()
        // let (selected_stream, set_stream) = use_state(cx, || SelectedStream::Football);

        // let opts = SelectedStream::iter().map(|name| rsx! { option { "{name}", value: "{name}" } });

        // cx.render(rsx! {
        //     div {
        //         h1 { "Tide basic CRUD app" }
        //         h2 { "Chosen stream: {selected_stream}" }
        //         select {
        //             value: {selected_stream.as_ref()}
        //             "{selected_stream}"
        //             {opts}
        //         }
        //     }
        // })
    };
}

/// Server-specific code
#[cfg(feature = "server")]
mod server {
    use async_std::sync::RwLock;
    pub use log::info;
    use std::sync::Arc;
    use tide::Request;
    use tide_websockets::{Message, WebSocket, WebSocketConnection};

    use crate::SelectedStream;

    // type ServerRequest = Request<Arc<RwLock<()>>>;
    type ServerRequest = Request<()>;
    // type ServerRequest = Request<Arc<RwLock<ServerState>>>;

    static CLIENT_PATH: &'static str = "";

    pub async fn app() -> anyhow::Result<()> {
        let mut app = tide::new();

        app.at("")
            .serve_dir(format!("{}/pkg", CLIENT_PATH))
            .expect("Cannot serve directory");

        app.at("/updates").get(WebSocket::new(socket_handler));

        let addr = "0.0.0.0:9001";
        log::info!("Congrats! Server is up and running at http://{}", addr);
        app.listen(addr).await?;

        Ok(())
    }

    async fn socket_handler(
        request: ServerRequest,
        stream: WebSocketConnection,
    ) -> tide::Result<()> {
        // clone the receiver channel
        // subscribe to any updates
        // let receiver = request.state().read().await.receiver.clone();
        // while let Ok(evt) = receiver.recv().await {
        //     let response_msg = serde_json::to_string(&evt)?;
        //     stream.send_string(response_msg).await?;
        // }

        Ok(())
    }

    use dioxus_core::prelude::*;

    #[derive(PartialEq, Props)]
    struct SreamListProps {
        selected_stream: SelectedStream,
    }

    static STREAM_LIST: FC<SreamListProps> = |cx| {
        //
        match cx.selected_stream {
            SelectedStream::Football => cx.render(rsx! {
                li {
                    "watch football!"
                }
            }),

            _ => unimplemented!()
            // .render(cx),
            // SelectedStream::Hockey => rsx! {
            //     li {
            //         "watch football!"
            //     }
            // }
            // .render(cx),
            // SelectedStream::Socker => rsx! {
            //     li {
            //         "watch football!"
            //     }
            // }
            // .render(cx),
        }
    };
}

mod ergorsx {

    // struct Ncx {}

    // struct VVNode {}
    // struct DTree {
    //     // struct DTree<F: Fn(&Ncx) -> VVNode> {
    //     caller: F,
    // }
    // impl<F: Fn(&Ncx) -> VVNode> DTree<F> {
    //     fn new(f: F) -> Self {
    //         Self { caller: f }
    //     }
    // }

    // trait Renderable {
    //     fn render(self, nodecx: &Ncx) -> VVNode;
    // }

    // impl<F: Fn(&Ncx) -> VVNode> Renderable for DTree<F> {
    //     fn render(self, nodecx: &Ncx) -> VVNode {
    //         (self.caller)(nodecx)
    //     }
    // }

    // fn test() {
    //     let t = 123;
    //     let r = match t {
    //         123 => DTree::new(|f| VVNode {}).render(cx),
    //         456 => DTree::new(|f| VVNode {}).render(cx),
    //         789 => DTree::new(|f| VVNode {}).render(cx),
    //         _ => unreachable!(),
    //     };
    // }

    // fn example() {
    //     rsx! {
    //         div {

    //         }
    //     }.render(cx)
    // }

    // fn example() {
    //     cx.render(rsx!{
    //         div {

    //         }
    //     })
    // }
}