//! A drop-in replacement for [`iced::Task`] that allows for easy evaluation for
//! testing.
mod wrappers;
pub use wrappers::*;
#[cfg(not(test))]
pub use iced::Task;
#[cfg(test)]
pub struct Task<T> {
    stream: Option<iced::futures::stream::BoxStream<'static, T>>,
}
#[cfg(test)]
pub async fn await_next_result<T>(tasks: &mut Task<T>) -> Option<T> {
    let Task { stream } = tasks;
    if let Some(stream) = stream.as_mut() {
        if let Some(msg) = iced::futures::stream::StreamExt::next(stream).await
        {
            return Some(msg);
        }
    }
    None
}
#[cfg(test)]
impl<T> Task<T> {
    pub fn none() -> Self {
        Self { stream: None }
    }
    pub fn done(value: T) -> Task<T>
    where
        T: Send + 'static,
    {
        Self::future(iced::futures::future::ready(value))
    }
    pub fn perform<A>(
        future: impl Future<Output = A> + Send + 'static,
        f: impl FnOnce(A) -> T + Send + 'static,
    ) -> Self
    where
        T: Send + 'static,
        A: Send + 'static,
    {
        Self::future(iced::futures::FutureExt::map(future, f))
    }
    pub fn run<A>(
        stream: impl iced::futures::stream::Stream<Item = A> + Send + 'static,
        f: impl Fn(A) -> T + Send + 'static,
    ) -> Self
    where
        T: 'static,
    {
        Self::stream(iced::futures::stream::StreamExt::map(stream, f))
    }
    pub fn batch(tasks: impl IntoIterator<Item = Self>) -> Self
    where
        T: 'static,
    {
        let mut select_all = iced::futures::stream::SelectAll::new();
        for task in tasks.into_iter() {
            if let Some(stream) = task.stream {
                select_all.push(stream);
            }
        }
        Self {
            stream: Some(iced::futures::stream::StreamExt::boxed(select_all)),
        }
    }
    pub fn map<O>(self, mut f: impl FnMut(T) -> O + Send + 'static) -> Task<O>
    where
        T: Send + 'static,
        O: Send + 'static,
    {
        self.then(move |output| Task::done(f(output)))
    }
    pub fn then<O>(
        self,
        mut f: impl FnMut(T) -> Task<O> + Send + 'static,
    ) -> Task<O>
    where
        T: Send + 'static,
        O: Send + 'static,
    {
        Task {
            stream: match self.stream {
                None => None,
                Some(stream) => Some(iced::futures::stream::StreamExt::boxed(
                    iced::futures::stream::StreamExt::flat_map(
                        stream,
                        move |output| {
                            f(output).stream.unwrap_or_else(|| {
                                iced::futures::stream::StreamExt::boxed(
                                    iced::futures::stream::empty(),
                                )
                            })
                        },
                    ),
                )),
            },
        }
    }
    pub fn future(future: impl Future<Output = T> + Send + 'static) -> Self
    where
        T: 'static,
    {
        Self::stream(iced::futures::stream::once(future))
    }
    pub fn stream(
        stream: impl iced::futures::stream::Stream<Item = T> + Send + 'static,
    ) -> Self
    where
        T: 'static,
    {
        Self {
            stream: Some(iced::futures::stream::StreamExt::boxed(stream)),
        }
    }
}
#[cfg(test)]
mod test {
    use super::*;
    #[tokio::test]
    async fn test_run_task() {
        let mut task = Task::done(123_usize);
        let result = await_next_result(&mut task).await;
        assert_eq!(result, Some(123_usize))
    }
}

//! Wrappers for iced tasks to allow testing.
use std::path::PathBuf;
use super::Task;
use iced::window;
/// Opens a new window with the given [`Settings`]; producing the [`Id`]
/// of the new window on completion.
pub fn open_window(
    settings: window::Settings,
) -> (window::Id, Task<window::Id>) {
    #[cfg(not(test))]
    let (window_id, task) = window::open(settings);
    #[cfg(test)]
    let (window_id, task) = {
        let _ = settings;
        let id = window::Id::unique();
        (id, Task::done(id))
    };
    (window_id, task)
}
/// Changes the icon of the window using an icon from the content of an image
/// file at the given path.
pub fn window_set_icon<T>(window_id: window::Id, path: PathBuf) -> Task<T>
where
    T: Send + 'static,
{
    #[cfg(not(test))]
    let set_icon_task = Task::perform(
        async move {
            use iced::advanced::graphics::image::image_rs::ImageFormat;
            let icon_bytes = tokio::fs::read(path).await.unwrap();
            window::icon::from_file_data(&icon_bytes, Some(ImageFormat::Png))
                .unwrap()
        },
        |msg| msg,
    )
    .then(move |icon| window::set_icon(window_id, icon));
    #[cfg(test)]
    let set_icon_task = {
        let _ = (window_id, path);
        Task::none()
    };
    set_icon_task
}
/// Focuses the next focusable widget.
pub fn widget_focus_next<T>() -> Task<T> {
    #[cfg(not(test))]
    let task = iced::widget::focus_next();
    #[cfg(test)]
    let task = Task::none();
    task
}

pub mod task;

use core::str;
use std::cmp;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;

use task::Task;

use inflorescence_view::{app, theme, Theme};

use inflorescence_view::{app, Theme};

use iced::{widget, window, Element, Subscription, Task};

use iced::{window, Element, Subscription};

use tokio::fs;

use std::cmp;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;

#[cfg(not(test))]

    use core::str;

        .theme(theme)

        .theme(inflorescence_view::theme)

        window::open(window::Settings::default());
    let set_icon_task = Task::perform(
        async {
            use iced::advanced::graphics::image::image_rs::ImageFormat;
            let icon_bytes = fs::read("assets/icon.png").await.unwrap();
            window::icon::from_file_data(&icon_bytes, Some(ImageFormat::Png))
                .unwrap()
        },
        |msg| msg,
    )
    .then(move |icon| window::set_icon(window_id, icon));

        task::open_window(window::Settings::default());
    let set_icon_task =
        // TODO: `include_bytes!`?
        task::window_set_icon(window_id, PathBuf::from("assets/icon.png"));

                    return widget::focus_next();

                    return task::widget_focus_next();

use crate::task::Task;

use iced::Task;

use crate::task::Task;

use iced::Task;

[dev-dependencies]
[dev-dependencies.tokio]
workspace = true
features = ["macros"]

 "tokio-macros",

]
[[package]]
name = "tokio-macros"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.100",