#[allow(clippy::let_and_return)]

    pin::Pin,

    pin::{pin, Pin},

use async_mutex::{
    Mutex as AsyncMutex, MutexGuard as AsyncMutexGuard, MutexGuardArc as AsyncMutexGuardOwned,
};

struct PollTask(TaskId);

enum PollTask {
    Task(TaskId),
}
type BoxedTaskFuture<E> = Box<dyn Future<Output = Result<(), E>>>;

    tasks: HashMap<TaskId, Pin<Box<dyn Future<Output = Result<(), E>>>>>,

    tasks: HashMap<TaskId, Pin<BoxedTaskFuture<E>>>,

    #[must_use]

            self.event_loop_proxy.send_event(PollTask(task_id)).unwrap();

            self.event_loop_proxy
                .send_event(PollTask::Task(task_id))
                .unwrap();

            let _ = winit_proxy.lock().unwrap().send_event(PollTask(task_id));

            let _ = winit_proxy
                .lock()
                .unwrap()
                .send_event(PollTask::Task(task_id));

        }
    }
    /// Retrieves the game lock
    fn get_lock<'a, S>(&'a mut self, game: &'a AsyncMutex<Game<S>>) -> AsyncMutexGuard<Game<S>>
    where
        S: 'static,
    {
        let winit_proxy = Mutex::new(self.event_loop_proxy.clone());
        let (tx, rx) = flume::bounded(1);
        let waker = waker_fn::waker_fn(move || {
            let id_to_poll = rx.recv().unwrap();
            let _ = winit_proxy
                .lock()
                .unwrap()
                .send_event(PollTask::Task(id_to_poll));
        });
        // self.lock_tasks.push_back(Box::pin(game.lock_arc()));
        loop {
            // Continuously try to get the lock until we succeed
            let fut = game.lock();
            let fut = pin!(fut);
            let poll_status = fut.poll(&mut Context::from_waker(&waker));
            if let Poll::Ready(res) = poll_status {
                break res;
            }
            // Drive the task loop
            if let Some(id) = self.tasks.keys().next().copied() {
                tx.send(id).unwrap();
            }

    fn get_lock_owned<S>(&mut self, game: Arc<AsyncMutex<Game<S>>>) -> AsyncMutexGuardOwned<Game<S>>
    where
        S: 'static,
    {
        let winit_proxy = Mutex::new(self.event_loop_proxy.clone());
        let (tx, rx) = flume::unbounded();
        let waker = waker_fn::waker_fn(move || {
            let id_to_poll = rx.recv().unwrap();
            let _ = winit_proxy
                .lock()
                .unwrap()
                .send_event(PollTask::Task(id_to_poll));
        });
        // self.lock_tasks.push_back(Box::pin(game.lock_arc()));
        let mut fut = Box::pin(game.lock_arc());
        loop {
            let fut = pin!(fut.as_mut());
            let poll_status = fut.poll(&mut Context::from_waker(&waker));
            if let Poll::Ready(res) = poll_status {
                break res;
            }
            // Drive the task loop
            if let Some(id) = self.tasks.keys().next().copied() {
                tx.send(id).unwrap();
            }
        }
    }

        let on_document = |doc: web_sys::Document| {
            if let Some(canvas) = window.canvas() {
                let dst = doc.get_element_by_id("game")?;
                dst.append_child(&canvas).ok()?;
            }
            Some(())
        };

            .and_then(|doc| {
                if let Some(canvas) = window.canvas() {
                    let dst = doc.get_element_by_id("game")?;
                    dst.append_child(&canvas).ok()?;
                }
                Some(())
            })

            .and_then(on_document)

    let game = Arc::new(Mutex::new(game));

    #[allow(clippy::arc_with_non_send_sync)]
    let game = Arc::new(AsyncMutex::new(game));

            if !game.lock().unwrap().input(event) {

            if !winit_executor.get_lock(&game).input(event) {

                        let mut game = game.lock().unwrap();

                        let mut game = winit_executor.get_lock(&game);

                        game.lock().unwrap().screen_mut().resize(*phys_size);

                        let mut game = winit_executor.get_lock(&game);
                        game.screen_mut().resize(*phys_size);

            let game = game.clone();

            let mut game = winit_executor.get_lock_owned(game.clone());

                .spawn(async move { game.lock().unwrap().create_surface().await })

                .spawn({
                    async move {
                        let future = game.create_surface();
                        future.await
                    }
                })

        Event::UserEvent(PollTask(tid)) => {
            if let Some(res) = winit_executor.poll(tid) {
                // the stuff here shouldn't fail
                res.unwrap()

        Event::UserEvent(poll_task) => {
            match poll_task {
                // a certain task needs polling
                PollTask::Task(tid) => {
                    if let Some(res) = winit_executor.poll(tid) {
                        // the stuff here shouldn't fail
                        res.unwrap()
                    }
                }

            let mut game = game.lock().unwrap();

            let mut game = winit_executor.get_lock(&game);

    "--all-targets",

    "--target", "wasm32-unknown-unknown",

async-mutex = "1.4.0"
flume = "0.11.0"

name = "async-mutex"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "479db852db25d9dbf6204e6cb6253698f175c15726470f78af0d918e99d6156e"
dependencies = [
 "event-listener",
]
[[package]]

 "async-mutex",

 "flume",

name = "event-listener"
version = "2.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
[[package]]

 "futures-core",
 "futures-sink",
 "nanorand",

]
[[package]]
name = "nanorand"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
dependencies = [
 "getrandom",

cargo = { features = ["desktop"] }

cargo = { features = ["desktop"], target_dir = "target-dev" }
check = { command = "clippy" }