use std::{
    collections::HashMap,
    future::Future,
    pin::{pin, Pin},
    sync::{Arc, Mutex},
    task::{Context, Poll},
    time::Duration,
};

use std::{sync::Arc, time::Duration};

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

use async_mutex::Mutex as AsyncMutex;

    event_loop::{ControlFlow, EventLoop, EventLoopBuilder, EventLoopProxy},

    event_loop::{ControlFlow, EventLoop, EventLoopBuilder},

// Poor man's executor for winit's poor man's async
// taken from https://github.com/rust-windowing/winit/issues/1199#issuecomment-1685122253
type TaskId = usize;
#[derive(Debug)]
enum PollTask {
    Task(TaskId),
}
type BoxedTaskFuture<E> = Box<dyn Future<Output = Result<(), E>>>;
struct WinitExecutor<E> {
    // a better implementation should use a vec of options here.
    tasks: HashMap<TaskId, Pin<BoxedTaskFuture<E>>>,
    event_loop_proxy: EventLoopProxy<PollTask>,
}
impl<E> WinitExecutor<E> {
    /// Create a new `WinitExecutor`, driven by the given event loop.
    pub fn new(event_loop_proxy: EventLoopProxy<PollTask>) -> Self {
        Self {
            tasks: HashMap::new(),
            event_loop_proxy,
        }
    }
    fn next_task_id(&self) -> TaskId {
        static NEXT_TASK_ID: std::sync::atomic::AtomicUsize =
            std::sync::atomic::AtomicUsize::new(0);
        NEXT_TASK_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
    }
    /// Spawn a task.
    ///
    /// This immediately polls the task once, and then schedules it to be
    /// polled again if needed, using a `UserEvent::PollTask` event.
    pub fn spawn(&mut self, task: impl Future<Output = Result<(), E>> + 'static) -> Result<(), E> {
        let task = Box::pin(task);
        let task_id = self.next_task_id();
        self.tasks.insert(task_id, task);
        if let Some(res) = self.poll(task_id) {
            res
        } else {
            self.event_loop_proxy
                .send_event(PollTask::Task(task_id))
                .unwrap();
            Ok(())
        }
    }

    /// Poll a task.
    ///
    /// Should be called when the event loop receives a `UserEvent::PollTask`.
    pub fn poll(&mut self, task_id: TaskId) -> Option<Result<(), E>> {
        // this wake only need to work once, I believe, so we could use some type of "oneshot box"
        // instead of a mutex?
        let winit_proxy = Mutex::new(self.event_loop_proxy.clone());
        let waker = waker_fn::waker_fn(move || {
            let _ = winit_proxy
                .lock()
                .unwrap()
                .send_event(PollTask::Task(task_id));
        });
        let task = self.tasks.get_mut(&task_id).unwrap().as_mut();
        match task.poll(&mut Context::from_waker(&waker)) {
            Poll::Ready(res) => {
                _ = self.tasks.remove(&task_id);
                Some(res)
            }
            Poll::Pending => None,
        }
    }
    /// 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 event_loop: EventLoop<PollTask> =
        EventLoopBuilder::<PollTask>::with_user_event().build()?;

    let event_loop: EventLoop<()> = EventLoopBuilder::new().build()?;

    let assets = Arc::new(assets_manager::AssetCache::with_source(source));

    let game = match Game::new(window, source).await {

    let game = match Game::new(window, &assets).await {

    #[allow(clippy::arc_with_non_send_sync)]

    let el_proxy = event_loop.create_proxy();
    let mut winit_executor = WinitExecutor::new(el_proxy);

    let mut outer_cosync: cosync::Cosync<()> = cosync::Cosync::new();

    let mut avg_fps = 0.0;

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

            if !game.try_lock().unwrap().input(&assets, event) {

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

                        let mut game = game.try_lock().unwrap(); //winit_executor.get_lock(&game);

                        game.set_window_title(format!("Cat Waiter | FPS {avg_fps:03.2}"));
                        match game.render() {

                        match game.render(&assets) {

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

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

            let mut game = winit_executor.get_lock_owned(game.clone());
            winit_executor
                .spawn({
                    async move {
                        let future = game.create_surface();
                        future.await
                    }
                })
                .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 game = game.clone();
            let assets = assets.clone();
            outer_cosync.queue(|_input: cosync::CosyncInput<()>| async move {
                game.try_lock()
                    .unwrap()
                    .create_surface(&assets)
                    .await
                    .unwrap();
            })

            // poll cosync
            outer_cosync.run_until_stall(&mut ());

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

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

                game.update(LOGIC_DURATION);
                frames += 1.0;
            }
            if frames > 0.0 {
                avg_fps = (avg_fps + (frames / LOGIC_DURATION.as_secs_f64())) / 2.0;

                game.update(LOGIC_DURATION, &assets);

use cosync::Cosync;

    current_scene: Box<dyn Scene<S>>,

    current_scene: Box<dyn Scene<S> + Send>,

    internal_state: GameState<S>,
    executor: Cosync<GameState<S>>,

    internal_state: GameState,
    // executor: Cosync<GameState<S>>,

pub struct GameState<S> {
    pub assets: AssetCache<S>,

pub struct GameState {

    pub assets: &'a mut AssetCache<S>,

    pub assets: &'a AssetCache<S>,

    pub executor: &'a mut Cosync<GameState<S>>,

    // pub executor: &'a mut Cosync<GameState<S>>,

    ($game: expr) => {

    ($game: expr, $assets: expr) => {

            assets: &mut $game.internal_state.assets,

            assets: $assets,

            executor: &mut $game.executor,

            // executor: &mut $game.executor,

    pub async fn new(window: Window, source: S) -> color_eyre::Result<Self>

    pub async fn new(window: Window, assets: &AssetCache<S>) -> color_eyre::Result<Self>

        let mut assets = AssetCache::with_source(source);

        let mut executor = Cosync::new();

            assets: &mut assets,

            assets,

            executor: &mut executor,

            // executor: &mut executor,

            executor,

            // executor,

            text: TextSystem::new(&assets)?,

            text: TextSystem::new(assets)?,

                assets,

    pub async fn create_surface(&mut self) -> color_eyre::Result<()>

    pub async fn create_surface(&mut self, assets: &AssetCache<S>) -> color_eyre::Result<()>

        self.screen
            .create_surface(&self.internal_state.assets)
            .await

        self.screen.create_surface(assets).await

    pub fn set_window_title<T: AsRef<str>>(&self, new_title: T) {
        self.screen.window().set_title(new_title.as_ref())
    }

    pub fn gui_egui(&mut self) -> (egui::FullOutput, Vec<egui::ClippedPrimitive>) {

    pub fn gui_egui(
        &mut self,
        assets: &AssetCache<S>,
    ) -> (egui::FullOutput, Vec<egui::ClippedPrimitive>) {

            let mut view = extract_view!(self);

            let mut view = extract_view!(self, assets);

    pub fn input(&mut self, event: &WindowEvent) -> bool {

    pub fn input(&mut self, assets: &AssetCache<S>, event: &WindowEvent) -> bool {

        let mut view = extract_view!(self);

        let mut view = extract_view!(self, assets);

    pub fn update(&mut self, dt: std::time::Duration)

    pub fn update(&mut self, dt: std::time::Duration, assets: &AssetCache<S>)

        self.internal_state.assets.hot_reload();

        assets.hot_reload();

        self.executor.run_until_stall(&mut self.internal_state);

        // self.executor.run_until_stall(&mut self.internal_state);

        let mut view = extract_view!(self);

        let mut view = extract_view!(self, assets);

    pub fn render(&mut self) -> Result<(), RenderError>

    pub fn render(&mut self, assets: &AssetCache<S>) -> Result<(), RenderError>

        let (egui_output, paint_jobs) = self.gui_egui();

        let (egui_output, paint_jobs) = self.gui_egui(assets);

        self.text.prepare(&text_data, &self.internal_state.assets);

        self.text.prepare(&text_data, assets);

            .produce_camera(&text_data, &self.internal_state.assets)

            .produce_camera(&text_data, assets)

            .produce_world(&text_data, &self.internal_state.assets)

            .produce_world(&text_data, assets)

    pub fn get_scene<S>(&self, game: &mut GameView<S>, scene: SceneReference) -> Box<dyn Scene<S>> {

    pub fn get_scene<S>(
        &self,
        game: &mut GameView<S>,
        scene: SceneReference,
    ) -> Box<dyn Scene<S> + Send> {

poll-promise = "0.3.0"

  "cosmic-text/swash"]

  "cosmic-text/swash", "poll-promise/web"]

 "poll-promise",

name = "poll-promise"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f6a58fecbf9da8965bcdb20ce4fd29788d1acee68ddbb64f0ba1b81bccdb7df"
dependencies = [
 "document-features",
 "static_assertions",
 "wasm-bindgen",
 "wasm-bindgen-futures",
]
[[package]]