use inflorescence_iced_widget::{nav_scrollable, report};

use inflorescence_iced_widget::{dir_picker, nav_scrollable, report};

    IndexSet, Job, Log, ReadyState, RecordChanges, SubState,

    IndexSet, Job, Log, ManagingRepoSubState, ReadyState, RecordChanges,

    Column,

    PickingRepo(dir_picker::Msg),

        repo_path,

    match sub {
        model::SubState::PickingRepoDir(state) => {
            picking_repo(state, *window_size, allowed_actions, report)
        }
        model::SubState::ManagingRepo(state) => managing_repo(
            state,
            get_diff,
            *window_size,
            allowed_actions,
            report,
        ),
    }
}
fn picking_repo<'a>(
    state: &'a model::PickingRepoDir,
    window_size: iced::Size,
    allowed_actions: &'a [action::Binding],
    report: &'a report::Container,
) -> Element<'a, Msg, Theme> {
    let model::PickingRepoDir { picker } = state;
    let main = el(column([
        el(text("Select project directory:")),
        dir_picker::view(picker, theme::Container::Bordered)
            .map(Msg::PickingRepo),
    ])
    .spacing(SPACING)
    .width(Length::Fill)
    .height(Length::Fill));
    add_actions_and_report(None, main, window_size, allowed_actions, report)
}
fn managing_repo<'a, F>(
    state: &'a model::ManagingRepo,
    get_diff: F,
    window_size: iced::Size,
    allowed_actions: &'a [action::Binding],
    report: &'a report::Container,
) -> Element<'a, Msg, Theme>
where
    F: Fn(file::IdHash) -> Option<&'a diff::File>,
{
    let model::ManagingRepo { repo_path, sub } = state;

        SubState::Loading { .. } => {

        ManagingRepoSubState::Loading { .. } => {

            let actions_inner = column([]).spacing(4);
            let actions_inner =
                actions_inner.push(view_actions(allowed_actions));
            let actions = el(container(actions_inner)
                .class(theme::Container::ActionsBg)
                .width(Length::Fill)
                .height(Length::Shrink)
                .padding(Padding::from([2, 5])));
            let main = overlay_report(main, report, window_size);
            el(column([main, actions]))

            add_actions_and_report(
                None,
                main,
                window_size,
                allowed_actions,
                report,
            )

        SubState::SelectingId {

        ManagingRepoSubState::SelectingId {

        SubState::Ready(state) => view_ready(
            *window_size,

        ManagingRepoSubState::Ready(state) => view_ready(
            window_size,

fn add_actions_and_report<'a>(
    above_actions: Option<Column<'a, Msg, Theme>>,
    main: Element<'a, Msg, Theme>,
    window_size: iced::Size,
    allowed_actions: &'a [action::Binding],
    report: &'a report::Container,
) -> Element<'a, Msg, Theme> {
    let actions_inner = above_actions.unwrap_or_else(|| column([]).spacing(4));
    let actions_inner = actions_inner.push(view_actions(allowed_actions));
    let actions = el(container(actions_inner)
        .class(theme::Container::ActionsBg)
        .width(Length::Fill)
        .height(Length::Shrink)
        .padding(Padding::from([2, 5])));
    let main = overlay_report(main, report, &window_size);
    el(column([main, actions]).spacing(SPACING))
}

    allowed_actions: &[action::Binding],

    allowed_actions: &'a [action::Binding],

    let actions_inner = actions_inner.push(view_actions(allowed_actions));
    let actions = el(container(actions_inner)
        .class(theme::Container::ActionsBg)
        .width(Length::Fill)
        .height(Length::Shrink)
        .padding(Padding::from([2, 5])));
    // Overlay the main view with reports
    let main = overlay_report(main, report, &window_size);
    el(column([main, actions]).spacing(SPACING))

    add_actions_and_report(
        Some(actions_inner),
        main,
        window_size,
        allowed_actions,
        report,
    )

use inflorescence_model::model::{ReadyState, State, SubMenu, SubState};

use inflorescence_model::model::{
    ManagingRepo, ManagingRepoSubState, ReadyState, State, SubMenu, SubState,
};

    let sub = SubState::Loading {

    let sub = ManagingRepoSubState::Loading {

    let allowed_actions = action::get_allowed(&sub, &None, &report);

    let state = State {

    let state = ManagingRepo {
        repo_path: repo_path.clone(),
        sub,
    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {
        sub,

        repo_path: repo_path.clone(),
        sub,
        allowed_actions,

        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    let sub = SubState::Ready(ready_state);

    let sub = ManagingRepoSubState::Ready(ready_state);

    let allowed_actions = action::get_allowed(&sub, &None, &report);
    let state = State {
        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,

    let state = ManagingRepo {

        allowed_actions,

    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {
        sub,
        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,
        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    let sub = SubState::Ready(ready_state);

    let sub = ManagingRepoSubState::Ready(ready_state);

    let allowed_actions = action::get_allowed(&sub, &None, &report);
    let state = State {
        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,

    let state = ManagingRepo {

        allowed_actions,

    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {
        sub,
        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,
        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    let sub = SubState::Ready(ready_state);

    let sub = ManagingRepoSubState::Ready(ready_state);

    let allowed_actions = action::get_allowed(&sub, &None, &report);
    let state = State {

    let state = ManagingRepo {
        repo_path: repo_path.clone(),
        sub,
    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {
        sub,

        repo_path: repo_path.clone(),
        sub,
        allowed_actions,

        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    let sub = SubState::Ready(ready_state);

    let sub = ManagingRepoSubState::Ready(ready_state);

    let allowed_actions = action::get_allowed(&sub, &None, &report);
    let state = State {
        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,

    let state = ManagingRepo {

        sub,
    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {

        allowed_actions,

        window_size: WINDOW_SIZE,
        window_scale: WINDOW_SCALE,
        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    let sub = SubState::Ready(ready_state);

    let sub = ManagingRepoSubState::Ready(ready_state);

    let allowed_actions = action::get_allowed(&sub, &sub_menu, &report);
    let state = State {

    let state = ManagingRepo {
        repo_path: repo_path.clone(),
        sub,
    };
    let sub = SubState::ManagingRepo(state);
    let mut state = State {
        sub,

        repo_path: repo_path.clone(),
        sub,
        allowed_actions,

        allowed_actions: vec![],

    action::update_allowed_actions(&mut state);

    Bordered,

            Container::Bordered => container::Style {
                border: Border {
                    color: Color { a: 0.3, ..TURQOISE },
                    width: 2.0,
                    ..default()
                },
                ..default()
            },

pub fn el<'a, E, M>(e: E) -> Element<'a, M, Theme>

pub fn el<'a, E, M, Renderer>(e: E) -> Element<'a, M, Theme, Renderer>

    E: Into<Element<'a, M, Theme>>,

    E: Into<Element<'a, M, Theme, Renderer>>,

    Into::<Element<M, Theme>>::into(e)

    Into::<Element<M, Theme, Renderer>>::into(e)

use inflorescence_iced_widget::{nav_scrollable, report};

use inflorescence_iced_widget::{dir_picker, nav_scrollable, report};

pub fn is_ready(state: &State) -> Option<&ReadyState> {
    if let SubState::Ready(state) = &state.sub {

pub fn is_ready(state: &ManagingRepo) -> Option<&ReadyState> {
    if let ManagingRepoSubState::Ready(state) = &state.sub {

pub fn is_ready_mut(state: &mut State) -> Option<&mut ReadyState> {
    if let SubState::Ready(state) = &mut state.sub {

pub fn is_ready_mut(state: &mut ManagingRepo) -> Option<&mut ReadyState> {
    if let ManagingRepoSubState::Ready(state) = &mut state.sub {

    pub sub: SubState,

    pub repo_path: PathBuf,
    pub sub: SubState,

#[allow(clippy::large_enum_variant)]
#[derive(Debug)]
pub enum SubState {
    PickingRepoDir(PickingRepoDir),
    ManagingRepo(ManagingRepo),
}
#[derive(Debug)]
pub struct PickingRepoDir {
    pub picker: dir_picker::State,
}
#[derive(Debug)]
pub struct ManagingRepo {
    pub repo_path: PathBuf,
    pub sub: ManagingRepoSubState,
}

pub enum SubState {

pub enum ManagingRepoSubState {

use inflorescence_iced_widget::{nav_scrollable, report};

use inflorescence_iced_widget::nav_scrollable;

pub fn get_allowed(
    state: &model::SubState,
    sub_menu: &Option<model::SubMenu>,
    report: &report::Container,
) -> Vec<Binding> {
    let mut bindings = if let Some(sub_menu) = sub_menu {

pub fn update_allowed_actions(state: &mut model::State) {
    let mut bindings = if let Some(sub_menu) = state.sub_menu {

        match state {
            model::SubState::Loading { .. } => vec![],
            model::SubState::SelectingId { .. } => todo!(),
            model::SubState::Ready(ready_state) => {
                get_ready_allowed(ready_state)

        match &state.sub {
            model::SubState::PickingRepoDir(sub) => {
                get_allowed_in_picking_repo(sub)
            }
            model::SubState::ManagingRepo(sub) => {
                get_allowed_in_managing_repo(&sub.sub)

    if !report.entries.is_empty() {
        let label = if !report.hidden {

    if !state.report.entries.is_empty() {
        let label = if !state.report.hidden {

        if !report.hidden {

        if !state.report.hidden {

    state.allowed_actions = bindings;
}

    bindings

fn get_allowed_in_picking_repo(_state: &model::PickingRepoDir) -> Vec<Binding> {
    vec![down(), up()]
}
fn get_allowed_in_managing_repo(
    state: &model::ManagingRepoSubState,
) -> Vec<Binding> {
    match state {
        model::ManagingRepoSubState::Loading { .. } => vec![],
        model::ManagingRepoSubState::SelectingId { .. } => todo!(),
        model::ManagingRepoSubState::Ready(ready_state) => {
            get_ready_allowed(ready_state)
        }
    }

        ))),
    };
    let down = || Binding {
        key: "↓| j",
        label: "",
        msg: Some(FilteredMsg::Selection(selection::Msg::PressDir(
            selection::Dir::Down,
        ))),
    };
    let up = || Binding {
        key: "↑| k",
        label: "",
        msg: Some(FilteredMsg::Selection(selection::Msg::PressDir(
            selection::Dir::Up,

fn down() -> Binding {
    Binding {
        key: "↓| j",
        label: "",
        msg: Some(FilteredMsg::Selection(selection::Msg::PressDir(
            selection::Dir::Down,
        ))),
    }
}
fn up() -> Binding {
    Binding {
        key: "↑| k",
        label: "",
        msg: Some(FilteredMsg::Selection(selection::Msg::PressDir(
            selection::Dir::Up,
        ))),
    }
}

pub mod dir_picker;

//! A file-system directory picker
use async_stream::try_stream;
use iced::widget::{button, column, container, row, text, text_input};
use iced::{Element, Font, Length, Padding, Pixels};
use iced_utils::{task, Task};
use normpath::{BasePathBuf, PathExt};
use nucleo_matcher::pattern::{Atom, AtomKind, CaseMatching, Normalization};
use nucleo_matcher::Matcher;
use tokio::fs;
use std::borrow::Cow;
use std::cmp;
use std::collections::VecDeque;
use std::path::{self, Path, PathBuf};
use crate::nav_scrollable;
const PIJUL_DIR: &str = ".pijul";
const GIT_DIR: &str = ".git";
#[derive(Debug)]
pub struct State {
    left_nav: nav_scrollable::State,
    right_nav: nav_scrollable::State,
    input: String,
    current_dir: BasePathBuf,
    child_dirs: Vec<PathBuf>,
    matched_child_dirs: Vec<String>,
    found_repos_dirs_pijul: Vec<PathBuf>,
    found_repos_dirs_git: Vec<PathBuf>,
    find_child_dirs_handle: Option<task::Handle>,
    find_repos_handle: Option<task::Handle>,
    /// Fuzzy matcher state that avoid allocations during matching
    matcher: Matcher,
}
#[derive(Debug, Clone, Copy)]
pub enum RepoKind {
    Pijul,
    Git,
}
#[derive(Debug, Clone)]
pub enum Msg {
    Input(String),
    SubmitInput,
    SelectChildDir(PathBuf),
    EditSegment { ix: usize },
    FindChildDirsSuccess(Vec<PathBuf>),
    FindChildDirsFailed(String),
    FindReposDirsSuccess((PathBuf, RepoKind)),
    FindReposDirsFailed(String),
    SelectRepo(PathBuf),
}
pub fn init(start_path: impl Into<PathBuf>) -> (State, Task<Msg>) {
    let mut start_path = start_path.into();
    let current_dir = loop {
        match PathExt::normalize(start_path.as_path()) {
            Ok(path) => break path,
            Err(_) => {
                if let Some(path) = start_path.parent() {
                    start_path = path.to_path_buf();
                } else {
                    break BasePathBuf::new(PathBuf::from_iter([
                        path::Component::RootDir,
                    ]))
                    .expect("Must be able to construct root dir");
                }
            }
        }
    };
    let (find_child_dirs_task, find_child_dirs_handle) =
        find_child_dirs(current_dir.as_path());
    let find_child_dirs_handle = Some(find_child_dirs_handle);
    let (find_repos_task, find_repos_handle) =
        find_repos_dirs(current_dir.as_path());
    let find_repos_handle = Some(find_repos_handle);
    (
        State {
            left_nav: nav_scrollable::State::default(),
            right_nav: nav_scrollable::State::default(),
            input: String::default(),
            current_dir,
            child_dirs: vec![],
            matched_child_dirs: vec![],
            found_repos_dirs_pijul: vec![],
            found_repos_dirs_git: vec![],
            find_child_dirs_handle,
            find_repos_handle,
            matcher: Matcher::default(),
        },
        Task::batch([
            find_child_dirs_task,
            find_repos_task,
            // Focus the input
            task::widget_focus_next(),
        ]),
    )
}
#[derive(Debug)]
pub enum Action {
    Picked(PathBuf),
}
//
pub fn update(state: &mut State, msg: Msg) -> (Task<Msg>, Option<Action>) {
    let mut action = None;
    let task = match msg {
        Msg::Input(input) => {
            if input.is_empty() && state.input.is_empty() {
                // When there's an empty input and nothing is typed in (i.e.
                // indempotent delete), go up a dir
                if let Ok(Some(parent)) = state.current_dir.parent() {
                    change_dir(state, parent.to_owned())
                } else {
                    Task::none()
                }
            } else {
                if input.is_empty() {
                    state.matched_child_dirs = vec![];
                    state.input = input;
                    Task::none()
                } else {
                    let mut matches = if input.ends_with(PATH_SEP) {
                        // If the path ends with separator accept it only if
                        // there's an exact match
                        let (exact, _) = input.split_at(input.len() - 1);
                        if state.child_dirs.iter().any(|dir| {
                            dir.file_name().map(|name| name.to_string_lossy())
                                == Some(Cow::Borrowed(exact))
                        }) {
                            vec![input.to_string()]
                        } else {
                            vec![]
                        }
                    } else {
                        match_child_dirs(state, &input)
                    };
                    // Change dir if there is only one match
                    if matches.len() == 1 {
                        let matched =
                            state.current_dir.join(matches.pop().unwrap());
                        state.input = String::default();
                        change_dir(state, matched)
                    } else {
                        state.matched_child_dirs = matches;
                        state.input = input;
                        Task::none()
                    }
                }
            }
        }
        Msg::SubmitInput => {
            if state.input.is_empty() {
                action = Some(Action::Picked(
                    state.current_dir.as_path().to_path_buf(),
                ));
                Task::none()
            } else {
                // Accept input only if there's an exact match
                let mut matches = if state.child_dirs.iter().any(|dir| {
                    dir.file_name().map(|name| name.to_string_lossy())
                        == Some(Cow::Borrowed(&state.input))
                }) {
                    vec![state.input.clone()]
                } else {
                    vec![]
                };
                // Change dir if there is only one match
                if matches.len() == 1 {
                    let matched =
                        state.current_dir.join(matches.pop().unwrap());
                    state.input = String::default();
                    change_dir(state, matched)
                } else {
                    Task::none()
                }
            }
        }
        Msg::SelectChildDir(dir) => {
            state.input = String::default();
            let path = PathExt::normalize(dir.as_path()).unwrap();
            change_dir(state, path)
        }
        Msg::EditSegment { ix } => {
            let ix = cmp::max(ix, 1);
            let path: PathBuf =
                state.current_dir.as_path().iter().take(ix).collect();
            let path = PathExt::normalize(path.as_path()).unwrap();
            change_dir(state, path)
        }
        Msg::FindChildDirsSuccess(dirs) => {
            state.find_child_dirs_handle = None;
            state.child_dirs = dirs;
            // If the last char isn't path separator, update matches.
            // This is needed when `Msg::DeleteChar` deletes a path separator to
            // go up a dir
            if state.input.len() > 1 {
                let (_, last_char) =
                    state.input.split_at(state.input.len() - 1);
                if last_char != PATH_SEP_STR {
                    let input = PathBuf::from(&state.input);
                    let needle = input.file_name().unwrap().to_string_lossy();
                    let matches = match_child_dirs(state, &needle);
                    state.matched_child_dirs = matches;
                }
            }
            Task::none()
        }
        Msg::FindChildDirsFailed(_err) => {
            // TODO report error
            Task::none()
        }
        Msg::FindReposDirsSuccess((dir, kind)) => {
            match kind {
                RepoKind::Pijul => state.found_repos_dirs_pijul.push(dir),
                RepoKind::Git => state.found_repos_dirs_git.push(dir),
            }
            Task::none()
        }
        Msg::FindReposDirsFailed(_err) => {
            // TODO report error
            Task::none()
        }
        Msg::SelectRepo(dir) => {
            action = Some(Action::Picked(dir));
            Task::none()
        }
    };
    (task, action)
}
pub fn view<'a, Theme, Renderer>(
    state: &'a State,
    bordered_container_class: <Theme as container::Catalog>::Class<'a>,
) -> Element<'a, Msg, Theme, Renderer>
where
    Theme: 'a
        + button::Catalog
        + container::Catalog
        + nav_scrollable::Catalog
        + text::Catalog
        + text_input::Catalog,
    Renderer: 'a + iced::advanced::Renderer + iced::advanced::text::Renderer,
    <Renderer as iced_core::text::Renderer>::Font: From<iced::Font>,
{
    let State {
        left_nav,
        right_nav,
        input,
        current_dir,
        child_dirs,
        matched_child_dirs,
        found_repos_dirs_pijul,
        found_repos_dirs_git,
        find_child_dirs_handle: _,
        find_repos_handle,
        matcher: _,
    } = state;
    const CORNER: &str = "├─";
    const LAST_CORNER: &str = "└─";
    const CORNER_SIZE: Pixels = Pixels(24.0);
    let mut left_children =
        Vec::with_capacity(if state.find_child_dirs_handle.is_some() {
            1
        } else {
            if !matched_child_dirs.is_empty() {
                matched_child_dirs.len()
            } else {
                child_dirs.len()
            }
        });
    // Display path in segments so that changing level forces element tree
    // updates to avoid the annoying Iced state cache that prevents text_input
    // from updating
    let left_header = Element::new(
        container(row([
            Element::new(row(itertools::intersperse_with(
                current_dir.as_path().iter().enumerate().map(|(ix, comp)| {
                    Element::new(
                        button(text(comp.to_string_lossy()))
                            .on_press(Msg::EditSegment { ix }),
                    )
                }),
                || {
                    Element::new(
                        container(text(PATH_SEP_STR)).padding(
                            text_input::DEFAULT_PADDING.left(0).right(0),
                        ),
                    )
                },
            ))),
            Element::new(
                container(text(PATH_SEP_STR))
                    .padding(text_input::DEFAULT_PADDING.left(0).right(0)),
            ),
            Element::new(
                text_input("", input)
                    .on_input(Msg::Input)
                    .on_submit(Msg::SubmitInput),
            ),
        ]))
        .class(bordered_container_class)
        .padding(button::DEFAULT_PADDING),
    );
    const CHILDREN_PADDING: Padding = Padding {
        left: 20.0,
        ..Padding::ZERO
    };
    if state.find_child_dirs_handle.is_some() {
        left_children.push(Element::new(text("Loading child directories...")));
    } else if !matched_child_dirs.is_empty() {
        let last_matched_child_ix = matched_child_dirs.len().saturating_sub(1);
        left_children.extend(matched_child_dirs.iter().enumerate().map(
            |(ix, dir)| {
                Element::new(
                    row([
                        Element::new(
                            text(if ix == last_matched_child_ix {
                                LAST_CORNER
                            } else {
                                CORNER
                            })
                            .size(CORNER_SIZE)
                            .font(Font::MONOSPACE)
                            .shaping(text::Shaping::Advanced),
                        ),
                        Element::new(button(text(dir)).on_press_with(
                            move || {
                                Msg::SelectChildDir(
                                    current_dir.as_path().join(dir),
                                )
                            },
                        )),
                    ])
                    .padding(CHILDREN_PADDING),
                )
            },
        ));
    } else {
        let last_child_ix = child_dirs.len().saturating_sub(1);
        left_children.extend(child_dirs.iter().enumerate().map(|(ix, dir)| {
            let dir_str = dir.file_name().unwrap().to_string_lossy();
            Element::new(
                row([
                    Element::new(
                        text(if ix == last_child_ix {
                            LAST_CORNER
                        } else {
                            CORNER
                        })
                        .size(CORNER_SIZE)
                        .shaping(text::Shaping::Advanced),
                    ),
                    Element::new(
                        button(text(dir_str))
                            .on_press_with(|| Msg::SelectChildDir(dir.clone())),
                    ),
                ])
                .padding(CHILDREN_PADDING),
            )
        }));
    }
    let right_header = Element::new(text(
        if !found_repos_dirs_pijul.is_empty()
            || !found_repos_dirs_git.is_empty()
        {
            "Found repositories:"
        } else if find_repos_handle.is_none() {
            "No repositories found"
        } else {
            "Searching for repositories"
        },
    ));
    let right_children = found_repos_dirs_pijul
        .iter()
        .map(|dir| {
            Element::new(
                button(text(dir.to_string_lossy()))
                    .on_press_with(|| Msg::SelectRepo(dir.clone())),
            )
        })
        .chain(found_repos_dirs_git.iter().map(|dir| {
            Element::new(
                button(text(format!("{} (git)", dir.to_string_lossy())))
                    .on_press_with(|| Msg::SelectRepo(dir.clone())),
            )
        }))
        .collect::<Vec<_>>();
    // TODO make both scrollable
    let left = Element::new(
        container(column([
            left_header,
            Element::new(
                nav_scrollable(left_nav, left_children)
                    .height(Length::Fill)
                    .width(Length::Fill),
            ),
        ]))
        .height(Length::Fill)
        .width(Length::FillPortion(1)),
    );
    let right = Element::new(
        container(column([
            right_header,
            Element::new(
                nav_scrollable(right_nav, right_children)
                    .height(Length::Fill)
                    .width(Length::Fill),
            ),
        ]))
        .height(Length::Fill)
        .width(Length::FillPortion(1)),
    );
    Element::new(
        row([left, right])
            .spacing(SPACING)
            .width(Length::Fill)
            .height(Length::Fill),
    )
}
const SPACING: u32 = 10;
fn change_dir(state: &mut State, path: BasePathBuf) -> Task<Msg> {
    state.current_dir = path;
    state.found_repos_dirs_pijul = vec![];
    state.found_repos_dirs_git = vec![];
    state.matched_child_dirs = vec![];
    state.child_dirs = vec![];
    let (find_child_dirs_task, find_child_dirs_handle) =
        find_child_dirs(state.current_dir.as_path());
    state.find_child_dirs_handle = Some(find_child_dirs_handle);
    let (find_repos_dirs_task, find_repos_dirs_handle) =
        find_repos_dirs(state.current_dir.as_path());
    state.find_repos_handle = Some(find_repos_dirs_handle);
    Task::batch([find_child_dirs_task, find_repos_dirs_task])
}
fn find_child_dirs(dir: &Path) -> (Task<Msg>, task::Handle) {
    let current_dir = dir.to_owned();
    let (task, handle) = Task::perform(
        async move {
            let mut read_dir = fs::read_dir(&current_dir).await?;
            let mut child_dirs = vec![];
            while let Some(entry) = read_dir.next_entry().await? {
                let path = entry.path();
                let metadata = fs::metadata(&path).await?;
                if metadata.is_dir() && path.file_name().is_some() {
                    child_dirs.push(path);
                }
            }
            Ok(child_dirs)
        },
        |result: std::io::Result<_>| match result {
            Ok(dirs) => Msg::FindChildDirsSuccess(dirs),
            Err(error) => Msg::FindChildDirsFailed(error.to_string()),
        },
    )
    .abortable();
    let handle = handle.abort_on_drop();
    (task, handle)
}
fn find_repos_dirs(dir: &Path) -> (Task<Msg>, task::Handle) {
    // Breadth-first search for pijul repos
    let dir = dir.to_path_buf();
    let stream = try_stream! {
        let mut to_try = VecDeque::from([dir.to_path_buf()]);
        while let Some(path) = to_try.pop_front() {
            let mut reader = fs::read_dir(&path).await.map_err(|err| format!("Cannot read dir {} ({err})", path.to_string_lossy()
            ))?;
            // Ignore errors in accessing entries
            while let Ok(Some(entry)) = reader.next_entry().await {
                let metadata = fs::metadata(entry.path()).await;
                if metadata.map(|meta| meta.is_dir()).unwrap_or(false) {
                    let path = entry.path();
                    if let Ok(true) = fs::try_exists(path.join(PIJUL_DIR)).await {
                        yield (path, RepoKind::Pijul);
                    }
                    else if let Ok(true) = fs::try_exists(path.join(GIT_DIR)).await {
                        yield (path, RepoKind::Git);
                    } else {
                        to_try.push_back(path);
                    }
                }
            }
        }
    };
    let (task, handle) =
        Task::run(stream, |result: Result<_, String>| match result {
            Ok((dir, kind)) => Msg::FindReposDirsSuccess((dir, kind)),
            Err(error) => Msg::FindReposDirsFailed(error.to_string()),
        })
        .abortable();
    let handle = handle.abort_on_drop();
    (task, handle)
}
fn match_child_dirs(state: &mut State, needle: &str) -> Vec<String> {
    let atom = Atom::new(
        needle,
        CaseMatching::Ignore,
        Normalization::Never,
        AtomKind::Fuzzy,
        false,
    );
    itertools::Itertools::sorted_by(
        atom.match_list(
            state.child_dirs.iter().filter_map(|dir| {
                dir.file_name().map(|name| name.to_string_lossy())
            }),
            &mut state.matcher,
        )
        .into_iter(),
        // Sort by score descending
        |(_, left), (_, right)| Ord::cmp(right, left),
    )
    .map(|(dir, _score)| dir.to_string())
    .collect()
}
const PATH_SEP: char = path::MAIN_SEPARATOR;
const PATH_SEP_STR: &str = path::MAIN_SEPARATOR_STR;

[dependencies.async-stream]
workspace = true

[dependencies.itertools]
workspace = true

workspace = true
[dependencies.normpath]

[dependencies.nucleo-matcher]
workspace = true
[dependencies.tokio]
workspace = true

    selection, update, Msg, State,

    selection, update, ManagingRepoMsg, Msg, State,
};
use inflorescence_model::model::{
    ManagingRepoSubState, ReadyState, RecordChanges, SubState,

use inflorescence_model::action;
use inflorescence_model::model::{ReadyState, RecordChanges, SubState};

use inflorescence_model::{action, model};

    let (state, mut tasks) = init(repo_path.to_path_buf());

    let (state, mut tasks) = init(Some(repo_path.to_path_buf()));

    assert_eq!(state.model.repo_path, repo_path);

    assert_matches!(state.model.sub, model::SubState::ManagingRepo(_));
    if let model::SubState::ManagingRepo(sub) = state.model.sub {
        assert_eq!(sub.repo_path, repo_path);
    }

        if !loaded_id && matches!(msg, Msg::LoadedId(_)) {

        if !loaded_id
            && matches!(msg, Msg::ManagingRepo(ManagingRepoMsg::LoadedId(_)))
        {

        if !inited_repo && matches!(msg, Msg::FromRepo(repo::MsgOut::Init(_))) {

        if !inited_repo
            && matches!(
                msg,
                Msg::ManagingRepo(ManagingRepoMsg::FromRepo(
                    repo::MsgOut::Init(_)
                ))
            )
        {

        Msg::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)

        Msg::ManagingRepo(ManagingRepoMsg::ToRepo(
            repo::MsgIn::RefreshChangedAndUntrackedFiles
        ))

        Msg::FromRepo(repo::MsgOut::Refreshed {

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::Refreshed {

        })

        }))

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path }) if path == file_to_record

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path })) if path == file_to_record

        Msg::FromRepo(repo::MsgOut::Refreshed {

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::Refreshed {

        })

        }))

        Msg::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)

        Msg::ManagingRepo(ManagingRepoMsg::ToRepo(
            repo::MsgIn::RefreshChangedAndUntrackedFiles
        ))

    assert_matches!(&msg, Msg::FromRepo(repo::MsgOut::Refreshed { .. }));

    assert_matches!(
        &msg,
        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(
            repo::MsgOut::Refreshed { .. }
        ))
    );

        Msg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. })

        Msg::ManagingRepo(ManagingRepoMsg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. }))

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile {result:_, path }) if path == file_to_record

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::AddedUntrackedFile {result:_, path })) if path == file_to_record

        Msg::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)

        Msg::ManagingRepo(ManagingRepoMsg::ToRepo(
            repo::MsgIn::RefreshChangedAndUntrackedFiles
        ))

        Msg::FromRepo(repo::MsgOut::Refreshed {

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::Refreshed {

        })

        }))

        Msg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. })

        Msg::ManagingRepo(ManagingRepoMsg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. }))

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path })

        Msg::ManagingRepo(ManagingRepoMsg::FromRepo(repo::MsgOut::AddedUntrackedFile { result:_, path }))

        Msg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. })

        Msg::ManagingRepo(ManagingRepoMsg::File(crate::file::Msg::LoadedSrcFile { id: loaded_id, .. }))

        Msg::FromRepo(repo::MsgOut::RmedAddedFile { result:_, path })