fn main() {

    // The user interface and database will be run separately, and flume

    // channels will send `DatabaseCommand`s to do operations on the database

    // server.

    let (command_sender, command_receiver) = flume::unbounded();

    // Spawn an async task that processes commands sent by `command_sender`.

    App::spawn(process_database_commands(command_receiver));

    App::from(

        WindowBuilder::new(|storage| Component::new(GameInterface::new(command_sender), storage))

            .size(Size::new(512, 384))

            .title("Minority Game - BonsaiDb + Gooey Demo"),

    )

    // Register our custom component's transmogrifier.

    .with_component::<GameInterface>()

    // Run the app using the widget returned by the initializer.

    .run()

}

#[derive(Debug)]

    pub const fn new(command_sender: flume::Sender<DatabaseCommand>) -> Self {

        Self { command_sender }

    }

    fn build_content(

        &mut self,

        builder: <Self::Content as Content<Self>>::Builder,

        events: &EventMapper<Self>,

    ) -> StyledWidget<Layout> {

        builder

            .with(

                None,

                Label::new("This is an adaption of the game theory game \"Minority Game\". Choose between staying in or going out. If more than 50% of the players go out, everyone who goes out will lose happiness because they have a bad time when everything is crowded. However, if it's not too crowed, the players who chose to go out will gain a significant amount of happiness. Those who choose to stay in will gravitate toward 50% happiness."),

                WidgetLayout::build()

                    .top(Dimension::exact(20.))

                    .left(Dimension::exact(20.))

                    .right(Dimension::exact(20.))

                    .finish(),

            )

            .with(

                None,

                Label::new("Pick your choice:"),

                WidgetLayout::build()

                .bottom(Dimension::exact(100.))

                    .left(Dimension::exact(20.))

                    .finish(),

            )

            .with(

                GameWidgets::GoOut,

                Button::new(

                    "Go Out",

                    events.map(|_| GameInterfaceEvent::ChoiceClicked(Choice::GoOut)),

                ),

                WidgetLayout::build()

                    .left(Dimension::exact(200.))

                    .bottom(Dimension::exact(100.))

                    .finish(),

            )

            .with(

                GameWidgets::StayIn,

                Button::new(

                    "Stay In",

                    events.map(|_| GameInterfaceEvent::ChoiceClicked(Choice::StayIn)),

                ),

                WidgetLayout::build()

                    .left(Dimension::exact(250.))

                    .bottom(Dimension::exact(100.))

                    .finish(),

            )

            .with(

                None,

                Label::new("Pick your tell (Optional):"),

                WidgetLayout::build()

                    .bottom(Dimension::exact(60.))

                    .left(Dimension::exact(20.))

                    .finish(),

            )

            .with(

                GameWidgets::TellGoOut,

                Button::new(

                    "Go Out",

                    events.map(|_| GameInterfaceEvent::TellClicked(Choice::GoOut)),

                ),

                WidgetLayout::build()

                    .left(Dimension::exact(200.))

                    .bottom(Dimension::exact(60.))

                        .finish(),

            )

            .with(

                GameWidgets::TellStayIn,

                Button::new(

                    "Stay In",

                    events.map(|_| GameInterfaceEvent::TellClicked(Choice::StayIn)),

                ),

                WidgetLayout::build()

                .left(Dimension::exact(250.))

                .bottom(Dimension::exact(60.))

                    .finish(),

            )

            .with(

                GameWidgets::Status,

                Label::new("Ready to play."),

                WidgetLayout::build()

                    .bottom(Dimension::exact(20.))

                    .left(Dimension::exact(20.))

                    .right(Dimension::exact(20.))

                    .finish(),

            )

            .finish()

    }

    fn initialize(component: &mut Component<Self>, context: &Context<Component<Self>>) {

        let _ = component

            .behavior

            .command_sender

            .send(DatabaseCommand::Initialize(DatabaseContext {

                context: context.clone(),

            }));

    }

    fn receive_event(

        component: &mut Component<Self>,

        event: Self::Event,

        context: &Context<Component<Self>>,

    ) {

        match event {

            GameInterfaceEvent::ChoiceClicked(choice) => {

                let _ = component

                    .behavior

                    .command_sender

                    .send(DatabaseCommand::SetChoice(choice));

            }

            GameInterfaceEvent::TellClicked(choice) => {

                let _ = component

                    .behavior

                    .command_sender

                    .send(DatabaseCommand::SetTell(choice));

            }

            GameInterfaceEvent::UpdateStatus(status) => {

                let label = component

                    .widget_state(&GameWidgets::Status, context)

                    .unwrap();

                let mut label = label.lock::<Label>(context.frontend()).unwrap();

                label.widget.set_label(status, &label.context);

            }

    }

#[derive(Clone, Debug, Hash, Eq, PartialEq)]

#[derive(Debug)]

#[derive(Clone)]

async fn client() -> bonsaidb::client::Builder {

                    let certificate = tokio::fs::read("minority-game.bonsaidb/public-certificate.der").await.unwrap();

                    Client::build("bonsaidb://127.0.0.1".parse().unwrap()).with_certificate(bonsaidb::client::fabruic::Certificate::from_der(certificate).unwrap())

                } else {

                    Client::build("bonsaidb://minority-game.gooey.rs".parse().unwrap())

                }

            }

        }

    }

}

async fn process_database_commands(receiver: flume::Receiver<DatabaseCommand>) {

    let database = match receiver.recv_async().await.unwrap() {

        DatabaseCommand::Initialize(context) => context,

        _ => unreachable!(),

    let client = client()

        .await

        .with_api_callback::<Welcome>(ApiCallback::new_with_context(

            database.clone(),

            |welcome: Welcome, database| async move {

                let _ = database.context.send_command(ComponentCommand::Behavior(

                    GameInterfaceEvent::UpdateStatus(format!(

                        "Welcome {}! Current happiness: {}",

                        welcome.player_id,

                        whole_percent(welcome.happiness),

                    )),

                ));

            },

        ))

        .with_api_callback::<RoundComplete>(ApiCallback::new_with_context(

            database.clone(),

            |api: RoundComplete, database| async move {

                let RoundComplete {

                    won,

                    happiness,

                    current_rank,

                    number_of_players,

                    number_of_liars,

                    number_of_tells,

                let _ = database.context.send_command(ComponentCommand::Behavior(GameInterfaceEvent::UpdateStatus(

                    format!("You {}! {}/{} players lied about their intentions. Current happiness: {}%. Ranked {} of {} players in the last round.",

                        if won {

                            "won"

                            "lost"

                        whole_percent(happiness),

                        current_rank,

                        number_of_players

                    )

                )));

            },

        ))

        .with_api_callback::<RoundPending>(ApiCallback::new_with_context(

            database.clone(),

            |api: RoundPending, database| async move {

                let RoundPending {

                    current_rank,

                    number_of_players,

                    seconds_remaining,

                    number_of_tells,

                    tells_going_out,

                } = api;

                let _ = database.context.send_command(ComponentCommand::Behavior(GameInterfaceEvent::UpdateStatus(

                    format!("Round starting in {} seconds! Ranked {} of {}. Current tells: {}/{} ({}%) going out.",

                        seconds_remaining,

                        current_rank,

                        number_of_players,

                        tells_going_out,

                        number_of_tells,

                        whole_percent(tells_going_out as f32 / number_of_tells as f32)

                    )

                )));

            },

        ))

        .finish()

        .expect("invalid configuration");

    while let Ok(command) = receiver.recv_async().await {

        match command {

            DatabaseCommand::SetChoice(choice) => {

                match client.send_api_request_async(&SetChoice(choice)).await {

                    Ok(ChoiceSet(choice)) => {

                        log::info!("Choice confirmed: {:?}", choice)

                    other => {

                        log::error!("Error sending request: {:?}", other);

            DatabaseCommand::SetTell(choice) => {

                match client.send_api_request_async(&SetTell(choice)).await {

                    Ok(ChoiceSet(choice)) => {

                        log::info!("Tell confirmed: {:?}", choice)

                    other => {

                        log::error!("Error sending request: {:?}", other);

            DatabaseCommand::Initialize(_) => unreachable!(),

}