let log = repo::get_log(&internal.repo, None, None);

    let log = repo::get_log(&internal.repo, None, None, None);

    pub log: Log,

    pub short_log: Log,
}
#[derive(Clone, Derivative, strum::Display)]
#[derivative(Debug)]
pub enum MsgIn {
    RefreshChangedAndUntrackedFiles,
    AddUntrackedFile {
        path: String,
    },
    RmAddedFile {
        path: String,
    },
    Record {
        msg: String,
        #[derivative(Debug = "ignore")]
        sk: Arc<SKey>,
    },
    GetChangeDiffs {
        hash: ChangeHash,
    },
    SwitchToChannel(String),
    ForkChannel(String),
    LoadEntireLog,
    LoadOtherChannelLog(String),
}
#[derive(Debug, Clone, strum::Display)]
pub enum MsgOut {
    Init(State),
    Refreshed {
        state: State,
        invalidate_logs: bool,
    },
    AddedUntrackedFile {
        path: String,
    },
    RmedAddedFile {
        path: String,
    },
    GotChangeDiffs {
        hash: ChangeHash,
        diffs: ChangedFiles,
    },
    LoadedEntireLog(Log),
    LoadedOtherChannelLog {
        channel: String,
        log: Log,
    },

}
#[derive(Clone, Derivative, strum::Display)]
#[derivative(Debug)]
pub enum MsgIn {
    RefreshChangedAndUntrackedFiles,
    AddUntrackedFile {
        path: String,
    },
    RmAddedFile {
        path: String,
    },
    Record {
        msg: String,
        #[derivative(Debug = "ignore")]
        sk: Arc<SKey>,
    },
    GetChangeDiffs {
        hash: ChangeHash,
    },
    SwitchToChannel(String),
    ForkChannel(String),
    LoadEntireLog,
}
#[derive(Debug, Clone, strum::Display)]
pub enum MsgOut {
    Init(State),
    Refreshed(State),
    AddedUntrackedFile {
        path: String,
    },
    RmedAddedFile {
        path: String,
    },
    /// The State is updated after making a record
    Recorded(State),
    GotChangeDiffs {
        hash: ChangeHash,
        diffs: ChangedFiles,
    },
    LoadedEntireLog(Log),

            let _ = msg_out_tx.send(MsgOut::Refreshed(state));

            let _ = msg_out_tx.send(MsgOut::Refreshed {
                state,
                // To be safe - this msg might be triggered from any change
                // reported by file watch
                invalidate_logs: true,
            });

            let _ = msg_out_tx.send(MsgOut::Recorded(state));

            let _ = msg_out_tx.send(MsgOut::Refreshed {
                state,
                invalidate_logs: true,
            });

            let _ = msg_out_tx.send(MsgOut::Refreshed(state));

            let _ = msg_out_tx.send(MsgOut::Refreshed {
                state,
                invalidate_logs: true,
            });

            let _ = msg_out_tx.send(MsgOut::Refreshed(state));

            let _ = msg_out_tx.send(MsgOut::Refreshed {
                state,
                invalidate_logs: false,
            });

                let log = get_log(&internal_state.repo, None, None);

                let log = get_log(&internal_state.repo, None, None, None);

        MsgIn::LoadOtherChannelLog(channel) => {
            let channel_returned: String;
            let log: Log;
            (internal_state, channel_returned, log) =
                spawn_blocking(move || {
                    let log = get_log(
                        &internal_state.repo,
                        Some(&channel),
                        None,
                        None,
                    );
                    (internal_state, channel, log)
                })
                .await
                .unwrap();
            let _ = msg_out_tx.send(MsgOut::LoadedOtherChannelLog {
                channel: channel_returned,
                log,
            });
        }

    let log = get_log(repo, offset, limit);

    let log = get_log(repo, Some(&channel), offset, limit);

        log,

        short_log: log,

    channel: Option<&str>,

    let cur_channel = txn
        .current_channel()
        .unwrap_or(pijul::DEFAULT_CHANNEL)

    let cur_channel = channel
        .unwrap_or_else(|| {
            txn.current_channel().unwrap_or(pijul::DEFAULT_CHANNEL)
        })

    let log = repo::get_log(&internal.repo, None, None);

    let log = repo::get_log(&internal.repo, None, None, None);

    let log = repo::get_log(&internal.repo, None, None);

    let log = repo::get_log(&internal.repo, None, None, None);

    let mut log = repo::get_log(&internal.repo, None, None);

    let mut log = repo::get_log(&internal.repo, None, None, None);

    let mut log = repo::get_log(&internal.repo, None, Some(limit));

    let mut log = repo::get_log(&internal.repo, None, None, Some(limit));

    let mut log = repo::get_log(&internal.repo, Some(offset), None);

    let mut log = repo::get_log(&internal.repo, None, Some(offset), None);

#[derive(Debug, Default)]
pub struct State {
    pub selected_sections: Vec<usize>,
    pub expanded_unchanged_sections: Vec<usize>,
    pub collapsed_changed_sections: Vec<usize>,

use std::borrow::Cow;
#[derive(Debug)]
pub enum FileContent<'a> {
    Decoded(Cow<'a, str>),
    UnknownEncoding,

pub mod selection;

use iced_expl_widget::nav_scrollable;

pub use libflorescence::diff::{

pub use inflorescence_model::diff::{

    DiffWithoutContents, File, Lines, Section, State, UndecodableContents,
    UndecodableFile,

    DiffWithoutContents, File, FileAndState, Lines, Section, State,
    UndecodableContents, UndecodableFile,

use std::cmp;

use crate::{el, theme, Theme};
use iced_expl_widget::nav_scrollable;

use crate::{el, theme, Theme};

use std::cmp;

use crate::{diff, el, selection, theme, Theme};

use crate::{diff, el, theme, Theme};

use inflorescence_model::{
    get_entire_log_diffs_nav, get_entire_log_files_nav, get_files_diffs_nav,
    get_status_log_diffs_nav, get_status_log_files_nav, selection, Log,
    ReadyState, RecordMsg, SubState,
};

use libflorescence::repo;

use libflorescence::{file, repo};

#[derive(Debug)]
pub struct State<'a> {
    pub window_size: iced::Size,
    pub repo_path: &'a Path,
    pub repo: Option<&'a Repo>,
    pub record_msg: Option<&'a RecordMsg>,
    /// Diff and state of selected log's file (untracked, changed or from a
    /// log), if any
    pub status_selection: Option<StatusSelection<'a>>,
    pub channel_selection: Option<&'a selection::Channel>,
    pub entire_log_selection: Option<EntireLogSelection<'a>>,
}
#[derive(Debug)]
pub struct Repo {
    pub state: repo::State,
    /// Scrollable status view contains the overview of untracked files,
    /// changed files and most recent log changes
    // pub status_nav: NavScrollable,
    pub status_nav: nav_scrollable::State,
    /// `true` when we're selecting a channel to switch to
    pub switching_channel: bool,
    /// `Some` when we're selecting a channel to switch to
    pub forking_channel: Option<String>,
    /// `Some` when looking at the entire log of changes
    pub entire_log: Option<EntireLog>,
}
#[derive(Debug)]
pub enum StatusSelection<'a> {
    UntrackedFile {
        ix: usize,
        path: &'a str,
        diff: Option<Diff<'a>>,
    },
    ChangedFile {
        ix: usize,
        path: &'a str,
        diff: Option<Diff<'a>>,
        is_added_from_untracked: bool,
    },
    Log {
        ix: usize,
        hash: repo::ChangeHash,
        message: &'a str,
        file: Option<LogChangeFileSelection<'a>>,
        nav: Option<&'a nav_scrollable::State>,
    },
}
#[derive(Debug)]
pub struct LogChangeFileSelection<'a> {
    pub ix: usize,
    pub path: &'a str,
    pub diff: Option<Diff<'a>>,
}
#[derive(Debug)]
pub struct Diff<'a> {
    pub is_selected: bool,
    pub file: &'a diff::File,
    pub state: &'a diff::State,
    pub nav: &'a nav_scrollable::State,
}
#[derive(Debug)]
pub enum EntireLog {
    Loading,
    LoadingButNotViewing,
    Got {
        log: repo::Log,
        nav: Box<nav_scrollable::State>,
    },
    NotViewing {
        log: repo::Log,
        nav: Box<nav_scrollable::State>,
    },
}
#[derive(Debug)]
pub struct EntireLogSelection<'a> {
    pub ix: usize,
    pub hash: repo::ChangeHash,
    pub message: &'a str,
    pub file: Option<LogChangeFileSelection<'a>>,
    pub nav: Option<&'a nav_scrollable::State>,
}
#[derive(Debug, Clone)]
pub enum Msg {
    Confirm,
    Cancel,
    Selection(selection::Msg),
    ToRepo(repo::MsgIn),
    EditRecordMsg(text_editor::Action),
    PostponeRecord,
    SaveRecord,
    DiscardRecord,
    AddUntrackedFile,
    RmAddedFile,
    StartRecord,
    /// Show a list of channels to switch to
    SelectChannel,
    ForkChannel,
    ForkChannelName(String),
    RefreshRepo,
    ShowEntireLog,
}

#[derive(Debug)]
pub enum RecordMsg {
    Typing(text_editor::Content),
    Canceled { old_msg: String },
}
pub fn view<'a>(
    state: State<'a>,

pub fn view<'a, F>(
    state: &'a inflorescence_model::State,
    get_diff: F,

) -> Element<'a, Msg, Theme> {
    let State {

) -> Element<'a, Msg, Theme>
where
    F: Fn(file::IdHash) -> Option<&'a diff::File>,
{
    let inflorescence_model::State {

        repo,
        record_msg,
        status_selection,
        channel_selection,
        entire_log_selection,

        sub,

    let inner = if let Some(repo) = repo {
        view_repo(
            window_size,
            repo_path,
            repo,
            record_msg,
            status_selection,
            channel_selection,
            entire_log_selection,
        )
    } else {
        el(text("Loading repo..."))

    let inner = match sub {
        SubState::Loading { .. } => el(text("Loading...")),
        SubState::SelectingId {
            user_ids: _,
            user_selection_ix: _,
            user_selection_nav: _,
            repo: _,
        } => todo!(),
        SubState::Ready(state) => {
            view_ready(*window_size, repo_path, state, get_diff)
        }

fn view_repo<'a>(

fn view_ready<'a, F>(

    // TODO show path

    repo: &'a Repo,
    record_msg: Option<&'a RecordMsg>,
    status_selection: Option<StatusSelection<'a>>,
    channel_selection: Option<&'a selection::Channel>,
    entire_log_selection: Option<EntireLogSelection<'a>>,
) -> Element<'a, Msg, Theme> {
    let Repo {
        state:

    state: &'a ReadyState,
    get_diff: F,
) -> Element<'a, Msg, Theme>
where
    F: Fn(file::IdHash) -> Option<&'a diff::File>,
{
    let ReadyState {
        user_id: _,
        repo:

                log,

                short_log,

        status_nav,
        switching_channel,
        forking_channel,
        entire_log,
    } = repo;

        selection,
        navigation,
        record_msg,
        forking_channel_name,
        logs,
    } = state;
    let selection = selection::unify(selection);

                let is_selected = matches!(status_selection.as_ref() ,
                    Some(StatusSelection::UntrackedFile{ ix: selected_ix, .. }) if &ix == selected_ix

                let is_selected = matches!(selection,
                    selection::Unified::Status(Some(selection::Status::UntrackedFile{ ix: selected_ix, .. })) if &ix == selected_ix

                let is_selected = matches!(status_selection.as_ref(),
                    Some(StatusSelection::ChangedFile{ ix: selected_ix, .. }) if &ix == selected_ix

                let is_selected = matches!(selection,
                    selection::Unified::Status(Some(selection::Status::ChangedFile{ ix: selected_ix, .. })) if &ix == selected_ix

        log.iter().enumerate().map(

        short_log.iter().enumerate().map(

                let is_selected = matches!(status_selection.as_ref(),
                    Some(StatusSelection::Log { ix: selected_ix, .. }) if &ix == selected_ix

                let is_selected = matches!(selection,
                    selection::Unified::Status(Some(selection::Status::LogChange(selection::LogChange{ ix: selected_ix, .. }))) if &ix == selected_ix

    let selection_details = || match status_selection.as_ref() {
        Some(StatusSelection::UntrackedFile { ix: _, path, diff }) => {
            let diffs = match diff {
                Some(Diff {
                    is_selected,
                    file,
                    state,
                    nav,
                }) => diff::view(state, nav, file, *is_selected),
                None => el(text("Loading diff...")),
            };

    let selection_details = || {
        if let selection::Unified::Status(selection) = selection {
            match selection {
                Some(selection::Status::UntrackedFile {
                    ix: _,
                    path,
                    diff_selected,
                }) => {
                    let id_hash =
                        file::id_parts_hash(path, file::Kind::Untracked);
                    let diff = get_diff(id_hash);
                    let state = navigation.files_diffs.diffs.get(&id_hash);
                    let nav = get_files_diffs_nav(navigation, id_hash);
                    let diffs = match diff.zip(state).zip(nav) {
                        Some(((file, state), nav)) => {
                            diff::view(state, nav, file, *diff_selected)
                        }
                        None => el(text("Loading diff...")),
                    };

            el(column([
                view_diff_header(format!("Untracked file {path} contents:")),
                diffs,
            ])
            .spacing(SPACING))
        }
        Some(StatusSelection::ChangedFile {
            path,
            ix: _,
            diff,
            is_added_from_untracked: _,
        }) => {
            let diffs = match diff {
                Some(Diff {
                    is_selected,

                    el(column([
                        view_diff_header(format!(
                            "Untracked file {path} contents:"
                        )),
                        diffs,
                    ])
                    .spacing(SPACING))
                }
                Some(selection::Status::ChangedFile {
                    path,
                    ix: _,
                    diff_selected,
                }) => {
                    let id_hash =
                        file::id_parts_hash(path, file::Kind::Changed);
                    let diff = get_diff(id_hash);
                    let state = navigation.files_diffs.diffs.get(&id_hash);
                    let nav = get_files_diffs_nav(navigation, id_hash);
                    let diffs = match diff.zip(state).zip(nav) {
                        Some(((file, state), nav)) => {
                            diff::view(state, nav, file, *diff_selected)
                        }
                        None => el(text("Loading diff...")),
                    };
                    el(column([
                        view_diff_header(format!("Changed file {path} diff:")),
                        diffs,
                    ])
                    .spacing(SPACING))
                }
                Some(selection::Status::LogChange(selection::LogChange {
                    ix,
                    hash,
                    message,

                    state,
                    nav,
                }) => diff::view(state, nav, file, *is_selected),
                None => el(text("Loading diff...")),
            };
            el(column([
                view_diff_header(format!("Changed file {path} diff:")),
                diffs,
            ])
            .spacing(SPACING))
        }
        Some(StatusSelection::Log {
            ix,
            hash,
            message,
            nav,
            file,
        }) => {
            let entry = log.get(*ix).unwrap();

                })) => {
                    let entry = short_log.get(*ix).unwrap();

            let short_hash = display_short_hash(hash);

                    let short_hash = display_short_hash(hash);

            let view = match nav {
                Some(nav) => {
                    let change_selected = match file.as_ref() {
                        Some(LogChangeFileSelection { diff, .. }) => !diff
                            .as_ref()
                            .map(|diff| diff.is_selected)
                            .unwrap_or_default(),
                        _ => false,

                    let nav = get_status_log_files_nav(navigation, *hash);
                    let view = match nav {
                        Some(nav) => {
                            let change_selected = match file.as_ref() {
                                Some(selection::LogChangeFileSelection {
                                    ix: _,
                                    path: _,
                                    diff_selected,
                                }) => *diff_selected,
                                _ => false,
                            };
                            let files = entry.file_paths.iter().enumerate().map(|(ix, path)| {
                                let is_selected = matches!(file, Some(selection::LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);
                                el(button(text(path)).on_press_with(move || {
                                    Msg::Selection(selection::Msg::Select(selection::Select::LogChangeFile { ix, path: path.clone() }))
                                }).class(selectable_button_class(is_selected)))
                            });
                            el(nav_scrollable(nav, files)
                                .class(if change_selected {
                                    theme::Scrollable::Selected
                                } else {
                                    theme::Scrollable::Normal
                                })
                                .width(Length::Fill)
                                .height(Length::Fill))
                        }
                        None => el(text("Loading...")),

                    let files = entry.file_paths.iter().enumerate().map(|(ix, path)| {
                        let is_selected = matches!(file, Some(LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);
                        el(button(text(path)).on_press_with(move || {
                            Msg::Selection(selection::Msg::Select(selection::Select::LogChangeFile { ix, path: path.clone() }))
                        }).class(selectable_button_class(is_selected)))
                    });
                    el(nav_scrollable(nav, files)
                        .class(if change_selected {
                            theme::Scrollable::Selected
                        } else {
                            theme::Scrollable::Normal
                        })
                        .width(Length::Fill)
                        .height(Length::Fill))

                    el(column([
                        view_diff_header(format!("{short_hash} message:")),
                        el(text(message).shaping(text::Shaping::Advanced)),
                        view_diff_header("Changed files:".to_string()),
                        view,
                    ])
                    .width(Length::Fill)
                    .height(Length::Fill)
                    .spacing(SPACING))

                None => el(text("Loading...")),
            };
            el(column([
                view_diff_header(format!("{short_hash} message:")),
                el(text(*message).shaping(text::Shaping::Advanced)),
                view_diff_header("Changed files:".to_string()),
                view,
            ])
            .width(Length::Fill)
            .height(Length::Fill)
            .spacing(SPACING))

                None => el(row([])),
            }
        } else {
            el(row([]))

        None => el(row([])),

    } else if let Some(EntireLogSelection { file, .. }) =
        entire_log_selection.as_ref()

    } else if let selection::Unified::EntireLog(Some(selection::LogChange {
        file,
        ..
    })) = selection

    } else if let Some(selection) = status_selection.as_ref() {

    } else if let selection::Unified::Status(Some(selection)) = selection {

            StatusSelection::UntrackedFile { .. }
            | StatusSelection::ChangedFile { .. }
            | StatusSelection::Log { file: None, .. } => 1,
            StatusSelection::Log { file: Some(_), .. } => 2,

            selection::Status::UntrackedFile { .. }
            | selection::Status::ChangedFile { .. }
            | selection::Status::LogChange(selection::LogChange {
                file: None,
                ..
            }) => 1,
            selection::Status::LogChange(selection::LogChange {
                file: Some(_),
                ..
            }) => 2,

    let status_selected = || match status_selection.as_ref() {
        Some(StatusSelection::UntrackedFile { diff, .. }) => !diff
            .as_ref()
            .map(|diff| diff.is_selected)
            .unwrap_or_default(),
        Some(StatusSelection::ChangedFile { diff, .. }) => !diff
            .as_ref()
            .map(|diff| diff.is_selected)
            .unwrap_or_default(),
        Some(StatusSelection::Log { file, .. }) => file.is_none(),
        None => true,
    };

    let status_selected =
        || match selection {
            selection::Unified::Status(Some(
                selection::Status::UntrackedFile { diff_selected, .. },
            )) => !diff_selected,
            selection::Unified::Status(Some(
                selection::Status::ChangedFile { diff_selected, .. },
            )) => !diff_selected,
            selection::Unified::Status(Some(selection::Status::LogChange(
                selection::LogChange { file, .. },
            ))) => file.is_none(),
            selection::Unified::Status(None) => true,
            selection::Unified::Channel(_)
            | selection::Unified::EntireLog(_) => false,
        };

            el(nav_scrollable(status_nav, status_nav_children())
                .class(if status_selected() {
                    theme::Scrollable::Selected
                } else {
                    theme::Scrollable::Normal
                })
                .width(Length::Fill)
                .height(Length::Fill)),

            el(
                nav_scrollable(&navigation.status_nav, status_nav_children())
                    .class(if status_selected() {
                        theme::Scrollable::Selected
                    } else {
                        theme::Scrollable::Normal
                    })
                    .width(Length::Fill)
                    .height(Length::Fill),
            ),

    let status_col_2 = || match status_selection.as_ref() {
        Some(StatusSelection::Log {
            ix: _,
            hash,
            message: _,
            file: Some(LogChangeFileSelection { ix: _, path, diff }),
            nav: _,
        }) => Some(el(column([
            el(column([
                view_diff_header(format!(
                    "{path} changes in {}:",
                    display_short_hash(hash)
                )),
                match diff {
                    Some(Diff {
                        is_selected,
                        file,
                        state,
                        nav,
                    }) => diff::view(state, nav, file, *is_selected),
                    None => el(text("Loading diff..")),

    let status_col_2 = || match selection {
        selection::Unified::Status(Some(selection::Status::LogChange(
            selection::LogChange {
                ix: _,
                hash,
                message: _,
                file:
                    Some(selection::LogChangeFileSelection {
                        ix: _,
                        path,
                        diff_selected,
                    }),
            },
        ))) => {
            let id_hash = file::log_id_parts_hash(*hash, path);
            let state = navigation.log_diffs.diffs.get(&id_hash);
            let nav = get_status_log_diffs_nav(navigation, id_hash);
            Some(el(column([
                el(column([
                    view_diff_header(format!(
                        "{path} changes in {}:",
                        display_short_hash(hash)
                    )),
                    match state.zip(nav) {
                        Some((diff::FileAndState { file, state }, nav)) => {
                            diff::view(state, nav, file, *diff_selected)
                        }
                        None => el(text("Loading diff..")),
                    },
                ])
                .spacing(SPACING)),
                // NOTE: This is currently never true - there are only up to 3
                // cols
                if hidden_cols == 2 {
                    el(button(row([el(
                        text("← Files").shaping(text::Shaping::Advanced)
                    )]))
                    .on_press(Msg::Selection(
                        selection::Msg::PressDir(selection::Dir::Left),
                    )))
                } else {
                    el(row([]))

            .spacing(SPACING)),
            // NOTE: This is currently never true - there are only up to 3
            // cols
            if hidden_cols == 2 {
                el(button(row([el(
                    text("← Files").shaping(text::Shaping::Advanced)
                )]))
                .on_press(Msg::Selection(
                    selection::Msg::PressDir(selection::Dir::Left),
                )))
            } else {
                el(row([]))
            },
        ])
        .width(Length::Fill)
        .height(Length::Fill)
        .spacing(SPACING))),
        Some(StatusSelection::UntrackedFile { .. })
        | Some(StatusSelection::ChangedFile { .. })
        | Some(StatusSelection::Log { .. })
        | None => None,

            .width(Length::Fill)
            .height(Length::Fill)
            .spacing(SPACING)))
        }
        _ => None,

    let entire_log_selected = || match entire_log_selection.as_ref() {
        Some(EntireLogSelection { file, .. }) => file.is_none(),
        None => false,

    let entire_log_selected = || match selection {
        selection::Unified::EntireLog(log_change) => match log_change {
            Some(selection::LogChange { file, .. }) => file.is_none(),
            None => true,
        },
        _ => false,

    let entire_log_change_selected = || match entire_log_selection.as_ref() {
        Some(EntireLogSelection {
            file: Some(LogChangeFileSelection { diff, .. }),
            ..
        }) => !diff
            .as_ref()
            .map(|diff| diff.is_selected)
            .unwrap_or_default(),

    let entire_log_change_selected = || match selection {
        selection::Unified::EntireLog(log_change) => match log_change {
            Some(selection::LogChange {
                file:
                    Some(selection::LogChangeFileSelection {
                        diff_selected, ..
                    }),
                ..
            }) => !*diff_selected,
            _ => false,
        },

    let other_channels_selected = || match selection {
        selection::Unified::Channel(channel) => match channel {
            Some(selection::Channel { log, .. }) => log.is_none(),
            None => true,
        },
        _ => false,
    };

        let Some(EntireLog::Got { log, nav }) = entire_log.as_ref() else {

        let Some(Log::Loaded { log }) = logs.entire_log.as_ref() else {

            let is_selected = matches!(entire_log_selection.as_ref(),
                Some(EntireLogSelection { ix: selected_ix, .. }) if &ix == selected_ix

            let is_selected = matches!(selection,
                selection::Unified::EntireLog(Some(selection::LogChange{ ix: selected_ix, .. })) if &ix == selected_ix

        let selected_ix = entire_log_selection
            .as_ref()
            .map(|EntireLogSelection { ix, .. }| len - *ix);

        let selected_ix = match selection {
            selection::Unified::EntireLog(Some(selection::LogChange {
                ix,
                ..
            })) => Some(len - *ix),
            _ => None,
        };

            el(nav_scrollable(nav, entries)

            el(nav_scrollable(&navigation.entire_log_nav, entries)

        let files_view = match entire_log_selection.as_ref() {
            Some(EntireLogSelection {

        let files_view = match selection {
            selection::Unified::EntireLog(Some(selection::LogChange {

                nav,
            }) => {

            })) => {

                let view = match (nav.as_ref(), entire_log.as_ref()) {
                    (Some(nav), Some(EntireLog::Got { log, nav: _ })) => {

                let nav = get_entire_log_files_nav(navigation, *hash);
                let view = match nav.as_ref().zip(logs.entire_log.as_ref()) {
                    Some((nav, Log::Loaded { log })) => {

                            let is_selected = matches!(file, Some(LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);

                            let is_selected = matches!(file, Some(selection::LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);

                    el(text(*message).shaping(text::Shaping::Advanced)),

                    el(text(message).shaping(text::Shaping::Advanced)),

            None => el(row([])),

            _ => el(row([])),

    let entire_log_col_2 = || match entire_log_selection.as_ref() {
        Some(EntireLogSelection {

    let entire_log_col_2 = || match selection {
        selection::Unified::EntireLog(Some(selection::LogChange {

            file: Some(LogChangeFileSelection { ix: _, path, diff }),
            nav: _,
        }) => Some(el(column([
            el(column([
                view_diff_header(format!(
                    "{path} changes in {}:",
                    display_short_hash(hash)
                )),
                match diff {
                    Some(Diff {
                        is_selected,
                        file,
                        state,
                        nav,
                    }) => diff::view(state, nav, file, *is_selected),
                    None => el(text("Loading diff..")),

            file:
                Some(selection::LogChangeFileSelection {
                    ix: _,
                    path,
                    diff_selected,
                }),
        })) => {
            let id_hash = file::log_id_parts_hash(*hash, path);
            let state = navigation.log_diffs.diffs.get(&id_hash);
            let nav = get_entire_log_diffs_nav(navigation, id_hash);
            Some(el(column([
                el(column([
                    view_diff_header(format!(
                        "{path} changes in {}:",
                        display_short_hash(hash)
                    )),
                    match state.zip(nav) {
                        Some((diff::FileAndState { file, state }, nav)) => {
                            diff::view(state, nav, file, *diff_selected)
                        }
                        None => el(text("Loading diff..")),
                    },
                ])
                .spacing(SPACING)),
                // NOTE: This is currently never true - there are only up to 3
                // cols
                if hidden_cols == 2 {
                    el(button(row([el(
                        text("← Files").shaping(text::Shaping::Advanced)
                    )]))
                    .on_press(Msg::Selection(
                        selection::Msg::PressDir(selection::Dir::Left),
                    )))
                } else {
                    el(row([]))

            .spacing(SPACING)),
            // NOTE: This is currently never true - there are only up to 3
            // cols
            if hidden_cols == 2 {
                el(button(row([el(
                    text("← Files").shaping(text::Shaping::Advanced)
                )]))
                .on_press(Msg::Selection(
                    selection::Msg::PressDir(selection::Dir::Left),
                )))
            } else {
                el(row([]))
            },
        ])
        .width(Length::Fill)
        .height(Length::Fill)
        .spacing(SPACING))),
        Some(EntireLogSelection { .. }) | None => None,

            .width(Length::Fill)
            .height(Length::Fill)
            .spacing(SPACING)))
        }
        _ => None,

            let is_selected = matches!(channel_selection,
                Some(selection::Channel{ ix: selected_ix, .. }) if &ix == selected_ix

            let is_selected = matches!(selection,
                selection::Unified::Channel(Some(selection::Channel{ ix: selected_ix, .. })) if &ix == selected_ix

    let main = if *switching_channel {
        if other_channels.is_empty() {
            el(column([el(text(format!("Current channel: {channel}")))])
                .width(Length::Fill)
                .height(Length::Fill))
        } else {
            el(column([
                el(text(format!("Current channel: {channel}. Switch to:"))),
                el(column(view_channels())),
            ])
            .width(Length::Fill)
            .height(Length::Fill))
        }
    } else if let Some(EntireLog::Loading) = entire_log.as_ref() {
        el(column([
            view_repo_info(),
            el(text("Entire log")),
            el(text("Loading...")),
        ])
        .width(Length::Fill)
        .height(Length::Fill))
    } else if let Some(EntireLog::Got { .. }) = entire_log.as_ref() {
        if let Some(entire_log_col_2) = entire_log_col_2() {
            let cols =
                [entire_log_col_0(), entire_log_col_1(), entire_log_col_2]

    let main = match selection {
        selection::Unified::Status(_) => {
            if let Some(status_col_2) = status_col_2() {
                let cols = [status_col_0(), status_col_1(), status_col_2]

            el(row(cols)
                .spacing(SPACING)

                el(row(cols)
                    .spacing(SPACING)
                    .width(Length::Fill)
                    .height(Length::Fill))
            } else {
                let cols = [status_col_0(), status_col_1()];
                el(row(cols)
                    .spacing(SPACING)
                    .width(Length::Fill)
                    .height(Length::Fill))
            }
        }
        selection::Unified::Channel(_) => {
            if other_channels.is_empty() {
                el(column([el(text(format!("Current channel: {channel}")))])
                    .width(Length::Fill)
                    .height(Length::Fill))
            } else {
                let nav = nav_scrollable(
                    &navigation.other_channels_nav,
                    view_channels(),
                )
                .class(if other_channels_selected() {
                    theme::Scrollable::Selected
                } else {
                    theme::Scrollable::Normal
                })

                .height(Length::Fill))
        } else {
            let cols = [entire_log_col_0(), entire_log_col_1()];
            el(row(cols)
                .spacing(SPACING)

                .height(Length::Fill);
                el(column([
                    el(text(format!("Current channel: {channel}"))),
                    el(nav),
                ])

            }

    } else if let Some(status_col_2) = status_col_2() {
        let cols = [status_col_0(), status_col_1(), status_col_2]
            .into_iter()
            .skip(hidden_cols);
        el(row(cols)
            .spacing(SPACING)

        selection::Unified::EntireLog(_) => match logs.entire_log.as_ref() {
            None | Some(Log::Loading) => el(column([
                view_repo_info(),
                el(text("Entire log")),
                el(text("Loading...")),
            ])

            .height(Length::Fill))
    } else {
        let cols = [status_col_0(), status_col_1()];
        el(row(cols)
            .spacing(SPACING)
            .width(Length::Fill)
            .height(Length::Fill))

            .height(Length::Fill)),
            Some(Log::Loaded { .. }) => {
                if let Some(entire_log_col_2) = entire_log_col_2() {
                    let cols = [
                        entire_log_col_0(),
                        entire_log_col_1(),
                        entire_log_col_2,
                    ]
                    .into_iter()
                    .skip(hidden_cols);
                    el(row(cols)
                        .spacing(SPACING)
                        .width(Length::Fill)
                        .height(Length::Fill))
                } else {
                    let cols = [entire_log_col_0(), entire_log_col_1()];
                    el(row(cols)
                        .spacing(SPACING)
                        .width(Length::Fill)
                        .height(Length::Fill))
                }
            }
        },

    let actions_inner = if let Some(forking_channel) = forking_channel {

    let actions_inner = if let Some(forking_channel) = forking_channel_name {

    let actions_inner = actions_inner.push(view_actions(action_state(
        repo,
        record_msg,
        status_selection,
        channel_selection,
        entire_log_selection,
    )));

    let actions_inner = actions_inner.push(view_actions(action_state(state)));

}
#[derive(Debug, Clone)]
pub enum Msg {
    Confirm,
    Cancel,
    Selection(selection::Msg),
    ToRepo(repo::MsgIn),
    EditRecordMsg(text_editor::Action),
    PostponeRecord,
    SaveRecord,
    DiscardRecord,
    AddUntrackedFile,
    RmAddedFile,
    StartRecord,
    /// Show a list of channels to switch to
    SelectChannel,
    ForkChannel,
    ForkChannelName(String),
    RefreshRepo,
    ShowEntireLog,

    let cant_confirm_already_exists =
        || el(action_button_inner("Enter", "already exists"));

    let cant_confirm =
        |label: &'static str| el(action_button_inner("Enter", label));

        ActionState::SwitchingChannel(state) => match state {

        ActionState::SelectingChannel(state) => match state {

                let row = add_if(
                    !can_switch,
                    || cant_confirm("cannot switch with unrecorded changes"),
                    row,
                );

            let row = add_if(!unique, cant_confirm_already_exists, row);

            let row =
                add_if(!unique, || cant_confirm("channel already exists"), row);

    SwitchingChannel(SwitchingChannelState),

    SelectingChannel(SwitchingChannelState),

fn action_state<'a>(
    repo: &'a Repo,
    record_msg: Option<&'a RecordMsg>,
    status_selection: Option<StatusSelection<'a>>,
    channel_selection: Option<&'a selection::Channel>,
    entire_log_selection: Option<EntireLogSelection<'a>>,
) -> ActionState {

fn action_state<'a>(state: &'a ReadyState) -> ActionState {
    let ReadyState {
        user_id: _,
        repo:
            repo::State {
                dir_name: _,
                channel,
                other_channels,
                untracked_files: _,
                changed_files,
                short_log: _,
            },
        selection,
        navigation,
        record_msg,
        forking_channel_name,
        logs: _,
    } = state;
    let selection::State {
        primary,
        status: status_selection,
        channel: channel_selection,
        entire_log: entire_log_selection,
        held_key: _,
    } = selection;

    if repo.switching_channel {
        let sub_state = if repo.state.other_channels.is_empty() {
            SwitchingChannelState::NoOtherChannels
        } else if channel_selection.is_some() {
            let can_switch = repo.state.changed_files.is_empty();
            SwitchingChannelState::SomethingSelected { can_switch }
        } else {
            SwitchingChannelState::NothingSelected
        };
        return ActionState::SwitchingChannel(sub_state);
    }
    if let Some(name) = repo.forking_channel.as_ref() {

    if let Some(name) = forking_channel_name.as_ref() {

        let unique = !repo.state.other_channels.iter().any(|n| n == name);

        let unique =
            channel != name && !other_channels.iter().any(|n| n == name);

    if let Some(EntireLogSelection { file, nav, .. }) = entire_log_selection {
        return match file {
            Some(LogChangeFileSelection {
                ix: _,
                path: _,
                diff,
            }) => {
                if let Some(diff) = diff {
                    if diff.is_selected {
                        ActionState::EntireLogChangeDiff

    match primary {
        selection::Primary::Status => {
            let can_record = !changed_files.is_empty();
            let has_other_channels = !other_channels.is_empty();
            match status_selection {
                Some(selection::Status::UntrackedFile {
                    ix: _,
                    path,
                    diff_selected,
                }) => {
                    let id_hash =
                        file::id_parts_hash(path, file::Kind::Untracked);
                    let nav = get_files_diffs_nav(navigation, id_hash);
                    if let Some(nav) = nav {
                        if *diff_selected {
                            ActionState::Diff {
                                can_record,
                                has_other_channels,
                            }
                        } else {
                            ActionState::Main {
                                selection: MainSelection::Untracked,
                                can_select_right:
                                    nav_scrollable::needs_scrolling(nav),
                                can_record,
                                has_other_channels,
                            }
                        }

                        ActionState::EntireLogChange {
                            can_select_right: nav_scrollable::needs_scrolling(
                                diff.nav,
                            ),

                        ActionState::Main {
                            selection: MainSelection::Untracked,
                            can_select_right: false,
                            can_record,
                            has_other_channels,

                } else {
                    ActionState::EntireLogChange {
                        can_select_right: false,
                    }

            }
            None => ActionState::EntireLog {
                can_select_right: nav
                    .map(nav_scrollable::needs_scrolling)
                    .unwrap_or_default(),
            },
        };
    }
    let can_record = !repo.state.changed_files.is_empty();
    let has_other_channels = !repo.state.other_channels.is_empty();
    match status_selection {
        Some(StatusSelection::UntrackedFile {
            ix: _,
            path: _,
            diff,
        }) => {
            if let Some(diff) = diff {
                if diff.is_selected {
                    ActionState::Diff {
                        can_record,
                        has_other_channels,

                Some(selection::Status::ChangedFile {
                    ix: _,
                    path,
                    diff_selected,
                }) => {
                    let is_added_from_untracked = changed_files
                        .get(path)
                        .map(|diffs| {
                            diffs.iter().any(|diff| {
                                matches!(diff, repo::ChangedFileDiff::Add)
                            })
                        })
                        .unwrap_or_default();
                    let main_selection = || {
                        if is_added_from_untracked {
                            MainSelection::AddedFromUntracked
                        } else {
                            MainSelection::Other
                        }
                    };
                    let id_hash =
                        file::id_parts_hash(path, file::Kind::Changed);
                    let nav = get_files_diffs_nav(navigation, id_hash);
                    if let Some(nav) = nav {
                        if *diff_selected {
                            ActionState::Diff {
                                can_record,
                                has_other_channels,
                            }
                        } else {
                            ActionState::Main {
                                selection: main_selection(),
                                can_select_right:
                                    nav_scrollable::needs_scrolling(nav),
                                can_record,
                                has_other_channels,
                            }
                        }
                    } else {
                        ActionState::Main {
                            selection: main_selection(),
                            can_select_right: false,
                            can_record,
                            has_other_channels,
                        }

                } else {
                    ActionState::Main {
                        selection: MainSelection::Untracked,
                        can_select_right: nav_scrollable::needs_scrolling(
                            diff.nav,
                        ),
                        can_record,
                        has_other_channels,

                }
                Some(selection::Status::LogChange(selection::LogChange {
                    ix: _,
                    hash,
                    message: _,
                    file,
                })) => {
                    let nav = get_status_log_files_nav(navigation, *hash);
                    match file {
                        Some(selection::LogChangeFileSelection {
                            ix: _,
                            path: _,
                            diff_selected,
                        }) => {
                            if let Some(nav) = nav {
                                if *diff_selected {
                                    ActionState::Diff {
                                        can_record,
                                        has_other_channels,
                                    }
                                } else {
                                    ActionState::LogChange {
                                        can_select_right:
                                            nav_scrollable::needs_scrolling(nav),
                                        can_record,
                                        has_other_channels,
                                    }
                                }
                            } else {
                                ActionState::LogChange {
                                    can_select_right: false,
                                    can_record,
                                    has_other_channels,
                                }
                            }
                        }
                        None => ActionState::Main {
                            selection: MainSelection::Other,
                            can_select_right: nav
                                .map(nav_scrollable::needs_scrolling)
                                .unwrap_or_default(),
                            can_record,
                            has_other_channels,
                        },

            } else {
                ActionState::Main {
                    selection: MainSelection::Untracked,

                None => ActionState::Main {
                    selection: MainSelection::Other,

                }

                },

        Some(StatusSelection::ChangedFile {
            ix: _,
            path: _,
            diff,
            is_added_from_untracked,
        }) => {
            let main_selection = || {
                if is_added_from_untracked {
                    MainSelection::AddedFromUntracked
                } else {
                    MainSelection::Other
                }

        selection::Primary::Channel => {
            let sub_state = if other_channels.is_empty() {
                SwitchingChannelState::NoOtherChannels
            } else if channel_selection.is_some() {
                let can_switch = changed_files.is_empty();
                SwitchingChannelState::SomethingSelected { can_switch }
            } else {
                SwitchingChannelState::NothingSelected

            if let Some(diff) = diff {
                if diff.is_selected {
                    ActionState::Diff {
                        can_record,
                        has_other_channels,
                    }
                } else {
                    ActionState::Main {
                        selection: main_selection(),
                        can_select_right: nav_scrollable::needs_scrolling(
                            diff.nav,
                        ),
                        can_record,
                        has_other_channels,

            return ActionState::SelectingChannel(sub_state);
        }
        selection::Primary::EntireLog => {
            if let Some(selection::LogChange { hash, file, .. }) =
                entire_log_selection
            {
                let nav = get_entire_log_files_nav(navigation, *hash);
                return match file {
                    Some(selection::LogChangeFileSelection {
                        ix: _,
                        path: _,
                        diff_selected,
                    }) => {
                        if let Some(nav) = nav {
                            if *diff_selected {
                                ActionState::EntireLogChangeDiff
                            } else {
                                ActionState::EntireLogChange {
                                    can_select_right:
                                        nav_scrollable::needs_scrolling(nav),
                                }
                            }
                        } else {
                            ActionState::EntireLogChange {
                                can_select_right: false,
                            }
                        }

                }

                    None => ActionState::EntireLog {
                        can_select_right: nav
                            .map(nav_scrollable::needs_scrolling)
                            .unwrap_or_default(),
                    },
                };

                ActionState::Main {
                    selection: main_selection(),

                ActionState::EntireLog {

                    can_record,
                    has_other_channels,

        Some(StatusSelection::Log {
            ix: _,
            hash: _,
            message: _,
            file,
            nav,
        }) => match file {
            Some(LogChangeFileSelection {
                ix: _,
                path: _,
                diff,
            }) => {
                if let Some(diff) = diff {
                    if diff.is_selected {
                        ActionState::Diff {
                            can_record,
                            has_other_channels,
                        }
                    } else {
                        ActionState::LogChange {
                            can_select_right: nav_scrollable::needs_scrolling(
                                diff.nav,
                            ),
                            can_record,
                            has_other_channels,
                        }
                    }
                } else {
                    ActionState::LogChange {
                        can_select_right: false,
                        can_record,
                        has_other_channels,
                    }
                }
            }
            None => ActionState::Main {
                selection: MainSelection::Other,
                can_select_right: nav
                    .map(nav_scrollable::needs_scrolling)
                    .unwrap_or_default(),
                can_record,
                has_other_channels,
            },
        },
        None => ActionState::Main {
            selection: MainSelection::Other,
            can_select_right: false,
            can_record,
            has_other_channels,
        },

        forking_channel: None,

        forking_channel_name: None,

        forking_channel: None,

        forking_channel_name: None,

[dependencies.inflorescence-model]
workspace = true

    /// Primary selection state. This is distinct from `status`, `channel`,
    /// `entire_log` sub-states fields to which each case corresponds, because
    /// they are preserved in different primary selection states.
    pub primary: Primary,
    /// Sub-selection in [`Primary::Status`] state

    /// Sub-selection in [`Primary::Channel`] state

    /// Sub-selection in [`Primary::EntireLog`] state

    /// Last directional key down that's not yet been released
    pub held_key: Option<HeldKey>,
}
#[derive(Debug)]
pub enum Unified<'a> {
    Status(Option<&'a Status>),
    Channel(Option<&'a Channel>),
    EntireLog(Option<&'a LogChange>),
}
#[derive(Debug, Default, Clone, Copy)]
pub enum Primary {
    #[default]
    Status,
    Channel,
    EntireLog,

    pub log: Option<LogChange>,

}
pub fn unify(state: &State) -> Unified<'_> {
    let State {
        primary,
        status,
        channel,
        entire_log,
        held_key: _,
    } = state;
    match primary {
        Primary::Status => Unified::Status(status.as_ref()),
        Primary::Channel => Unified::Channel(channel.as_ref()),
        Primary::EntireLog => Unified::EntireLog(entire_log.as_ref()),
    }

use crate::diff;
use iced_expl_widget::nav_scrollable;
use libflorescence::{file, repo};
use std::collections::HashSet;
#[derive(Debug, Default)]
pub struct FilesAndState {
    /// All the hashes in this set have `diffs` loaded.
    pub changes_with_loaded_diffs: HashSet<repo::ChangeHash>,
    /// All the diffs in this map have the change hash present in
    /// `change_with_loaded_diffs`
    pub diffs: file::LogIdMap<diff::FileAndState>,
}
#[derive(Debug, Default)]
pub struct Navs {
    /// Log change's files scrollable nav. Only the currently selected nav is
    /// kept.
    pub files_nav: Option<(repo::ChangeHash, nav_scrollable::State)>,
    /// Log file's diffs scrollable nav. Only the currently selected nav is
    /// kept.
    pub diffs_nav: Option<(file::LogIdHash, nav_scrollable::State)>,
}

pub mod diff;
pub mod log;
pub mod selection;
use iced_expl_widget::nav_scrollable;
use libflorescence::identity::Id;
use libflorescence::{file, repo};
use iced::widget::text_editor;
use std::collections::HashMap;
use std::path::PathBuf;
pub fn ready(state: &State) -> Option<&ReadyState> {
    if let SubState::Ready(state) = &state.sub {
        return Some(state);
    }
    None
}
pub fn ready_mut(state: &mut State) -> Option<&mut ReadyState> {
    if let SubState::Ready(state) = &mut state.sub {
        return Some(state);
    }
    None
}
#[derive(Debug)]
pub struct State {
    pub window_size: iced::Size,
    pub repo_path: PathBuf,
    pub sub: SubState,
}
#[derive(Debug)]
pub enum SubState {
    Loading {
        user_ids: Vec<Id>,
        repo: Option<repo::State>,
    },
    SelectingId {
        user_ids: Vec<Id>,
        user_selection_ix: usize,
        user_selection_nav: nav_scrollable::State,
        repo: Option<repo::State>,
    },
    Ready(ReadyState),
}
#[derive(Debug)]
pub struct ReadyState {
    pub user_id: Id,
    pub repo: repo::State,
    pub selection: selection::State,
    pub navigation: Navigation,
    pub record_msg: Option<RecordMsg>,
    /// `Some` when we're writing a name of the new channel forked from current
    pub forking_channel_name: Option<String>,
    pub logs: Logs,
}
#[derive(Debug)]
pub enum RecordMsg {
    Typing(text_editor::Content),
    Canceled { old_msg: String },
}
#[derive(Debug, Default)]
pub struct Navigation {
    /// Scrollable status view contains the overview of untracked files,
    /// changed files and most recent log changes
    pub status_nav: nav_scrollable::State,
    /// Logs shown in the status view.
    pub status_logs_navs: log::Navs,
    /// Other channels selection's nav
    pub other_channels_nav: nav_scrollable::State,
    /// Navs for a log of selected channel other than the current
    pub other_channel_log_navs: Option<(String, log::Navs)>,
    /// Entire log's change selection nav
    pub entire_log_nav: nav_scrollable::State,
    /// Logs for the entire log
    pub entire_logs_navs: log::Navs,
    /// Diffs for untracked and changed files shown in status view
    pub files_diffs: diff::FilesState,
    /// Diffs of status log changes, entire log changes and other channels'
    /// logs
    pub log_diffs: log::FilesAndState,
}
#[derive(Debug, Default)]
pub struct Logs {
    /// Populated when requested to look at the entire log of changes
    pub entire_log: Option<Log>,
    /// Keys are channel names
    pub other_channels_logs: HashMap<String, Log>,
}
#[derive(Debug)]
pub enum Log {
    Loading,
    Loaded { log: repo::Log },
}
/// Get untracked or changes files diff's nav if it matches given file ID
pub fn get_files_diffs_nav(
    navigation: &Navigation,
    id_hash: file::IdHash,
) -> Option<&nav_scrollable::State> {
    navigation
        .files_diffs
        .diffs_nav
        .as_ref()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}
/// Get untracked or changes files diff's nav if it matches given file ID
pub fn get_files_diffs_nav_mut(
    navigation: &mut Navigation,
    id_hash: file::IdHash,
) -> Option<&mut nav_scrollable::State> {
    navigation
        .files_diffs
        .diffs_nav
        .as_mut()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}
/// Get status log files nav if it matches given change hash
pub fn get_status_log_files_nav(
    navigation: &Navigation,
    hash: repo::ChangeHash,
) -> Option<&nav_scrollable::State> {
    navigation
        .status_logs_navs
        .files_nav
        .as_ref()
        .and_then(|(nav_hash, nav)| (*nav_hash == hash).then_some(nav))
}
/// Get status log files nav if it matches given change hash
pub fn get_status_log_files_nav_mut(
    navigation: &mut Navigation,
    hash: repo::ChangeHash,
) -> Option<&mut nav_scrollable::State> {
    navigation
        .status_logs_navs
        .files_nav
        .as_mut()
        .and_then(|(nav_hash, nav)| (*nav_hash == hash).then_some(nav))
}
/// Get status log diffs nav if it matches given log file ID
pub fn get_status_log_diffs_nav(
    navigation: &Navigation,
    id_hash: file::LogIdHash,
) -> Option<&nav_scrollable::State> {
    navigation
        .status_logs_navs
        .diffs_nav
        .as_ref()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}
/// Get status log diffs nav if it matches given log file ID
pub fn get_status_log_diffs_nav_mut(
    navigation: &mut Navigation,
    id_hash: file::LogIdHash,
) -> Option<&mut nav_scrollable::State> {
    navigation
        .status_logs_navs
        .diffs_nav
        .as_mut()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}
/// Get entire log files nav if it matches given change hash
pub fn get_entire_log_files_nav(
    navigation: &Navigation,
    hash: repo::ChangeHash,
) -> Option<&nav_scrollable::State> {
    navigation
        .entire_logs_navs
        .files_nav
        .as_ref()
        .and_then(|(nav_hash, nav)| (*nav_hash == hash).then_some(nav))
}
/// Get entire log files nav if it matches given change hash
pub fn get_entire_log_files_nav_mut(
    navigation: &mut Navigation,
    hash: repo::ChangeHash,
) -> Option<&mut nav_scrollable::State> {
    navigation
        .entire_logs_navs
        .files_nav
        .as_mut()
        .and_then(|(nav_hash, nav)| (*nav_hash == hash).then_some(nav))
}
/// Get entire log diffs nav if it matches given log file ID
pub fn get_entire_log_diffs_nav(
    navigation: &Navigation,
    id_hash: file::LogIdHash,
) -> Option<&nav_scrollable::State> {
    navigation
        .entire_logs_navs
        .diffs_nav
        .as_ref()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}
/// Get entire log diffs nav if it matches given log file ID
pub fn get_entire_log_diffs_nav_mut(
    navigation: &mut Navigation,
    id_hash: file::LogIdHash,
) -> Option<&mut nav_scrollable::State> {
    navigation
        .entire_logs_navs
        .diffs_nav
        .as_mut()
        .and_then(|(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav))
}

#[doc(inline)]
pub use libflorescence::diff::{
    contents_to_lines, Combined, DecodedFile, DiffWithContents,
    DiffWithoutContents, File, FileContent, Lines, Section,
    UndecodableContents, UndecodableFile,
};
use iced_expl_widget::nav_scrollable;
use libflorescence::file;
#[derive(Debug, Default)]
pub struct State {
    pub selected_sections: Vec<usize>,
    pub expanded_unchanged_sections: Vec<usize>,
    pub collapsed_changed_sections: Vec<usize>,
}
#[derive(Debug, Default)]
pub struct FilesState {
    pub diffs: file::IdMap<State>,
    /// Diffs scrollable nav.
    ///
    /// Only the current nav is kept because the sizes of contents have to be
    /// queried everytime the selection changes due to possible container size
    /// changes.
    pub diffs_nav: Option<(file::IdHash, nav_scrollable::State)>,
}
#[derive(Debug)]
pub struct FileAndState {
    pub file: File,
    pub state: State,
}

[package]
name = "inflorescence-model"
version.workspace = true
edition.workspace = true
license.workspace = true
authors.workspace = true
[dependencies]
# Internal dependencies
[dependencies.libflorescence]
workspace = true
[dependencies.iced-expl-widget]
workspace = true
# External dependencies
[dependencies.iced]
workspace = true

use iced_expl_widget::nav_scrollable;
use inflorescence_view::app;

pub use inflorescence_view::selection::{
    Channel, Dir, HeldKey, LogChange, LogChangeFileSelection, Msg, Select,
    State as ViewState, Status,

pub use inflorescence_model::selection::{
    unify, Channel, Dir, HeldKey, LogChange, LogChangeFileSelection, Msg,
    Primary, Select, State, Status, Unified,

use crate::{diff, file};

use crate::{diff, file, log};
use iced_expl_widget::nav_scrollable;
use inflorescence_model::{
    get_entire_log_diffs_nav_mut, get_entire_log_files_nav_mut,
    get_files_diffs_nav_mut, get_status_log_diffs_nav_mut,
    get_status_log_files_nav_mut, Log, Logs, Navigation,
};
use inflorescence_view::app;

#[derive(Debug, Default)]
pub struct State {
    pub view: ViewState,
    /// Last directional key down that's not yet been released
    pub held_key: Option<HeldKey>,

/// Hot potato
pub struct Ctx<'a> {
    pub state: &'a mut State,
    pub files: &'a mut file::State,
    pub navigation: &'a mut Navigation,
    pub repo: &'a repo::State,
    pub logs: &'a Logs,

    files_diffs: &mut diff::FilesState,
    status_logs: &mut diff::LogFilesAndState,
    entire_logs: &mut diff::LogFilesAndState,
    repo: Option<&mut app::Repo>,

    navigation: &mut Navigation,
    repo: &repo::State,
    logs: &Logs,

    let mut ctx = Ctx {
        state,
        files,
        navigation,
        repo,
        logs,
    };
    let mctx = &mut ctx;

                state.held_key.as_ref().and_then(

                mctx.state.held_key.as_ref().and_then(

            state.held_key = Some(HeldKey {

            mctx.state.held_key = Some(HeldKey {

                Dir::Down => select_down(
                    state,
                    files,
                    files_diffs,
                    status_logs,
                    entire_logs,
                    repo,
                    delta,
                ),
                Dir::Up => select_up(
                    state,
                    files,
                    files_diffs,
                    status_logs,
                    entire_logs,
                    repo,
                    delta,
                ),
                Dir::Left => select_left(state, repo.as_deref()),
                Dir::Right => select_right(
                    state,
                    files_diffs,
                    status_logs,
                    entire_logs,
                    repo.as_deref(),
                ),

                Dir::Down => select_down(mctx, delta),
                Dir::Up => select_up(mctx, delta),
                Dir::Left => select_left(mctx),
                Dir::Right => select_right(mctx),

        Msg::ReleaseDir(dir) => release(dir, state, files_diffs, status_logs),

        Msg::ReleaseDir(dir) => release(dir, mctx),

                state.held_key.as_ref().and_then(

                mctx.state.held_key.as_ref().and_then(

            state.held_key = Some(HeldKey {

            mctx.state.held_key = Some(HeldKey {

                Dir::Down => {
                    alt_select_down(state, files_diffs, status_logs, delta)
                }
                Dir::Up => {
                    alt_select_up(state, files_diffs, status_logs, delta)
                }

                Dir::Down => alt_select_down(mctx, delta),
                Dir::Up => alt_select_up(mctx, delta),

        Msg::Select(select) => select_exact(
            select,
            state,
            files,
            repo,
            files_diffs,
            status_logs,
            entire_logs,
        ),

        Msg::Select(select) => select_exact(select, mctx),

fn select_down(
    state: &mut State,
    files: &mut file::State,
    files_diffs: &mut diff::FilesState,
    status_logs: &mut diff::LogFilesAndState,
    entire_logs: &mut diff::LogFilesAndState,
    repo: Option<&mut app::Repo>,
    delta: Option<Duration>,
) -> Task<crate::Msg> {
    let Some(app::Repo {
        state: repo_state,
        status_nav,
        switching_channel,
        forking_channel: _,
        entire_log,
    }) = repo
    else {
        return Task::none();
    };
    if *switching_channel {
        let channels = &repo_state.other_channels;
        let selection = match state.view.channel.take() {
            Some(Channel { ix, name: _ }) => {
                let ix = if ix == channels.len() - 1 { 0 } else { ix + 1 };
                channel_selection(ix, channels)
            }
            None => {
                let ix = 0;
                channel_selection(ix, channels)
            }
        };
        state.view.channel = Some(selection);
        return Task::none();
    }
    if let Some(app::EntireLog::Got { log, nav }) = entire_log.as_mut() {
        let (selection, task) = if let Some(LogChange {
            ix: log_ix,
            hash,
            message,
            file,
        }) = state.view.entire_log.take()
        {
            match file {
                Some(LogChangeFileSelection {
                    ix: file_ix,
                    path,
                    diff_selected,
                }) => {
                    if diff_selected {
                        let id_hash = file::log_id_parts_hash(hash, &path);
                        let selection = LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(LogChangeFileSelection {
                                ix: file_ix,
                                path,
                                diff_selected,
                            }),
                        };
                        if let Some(nav) = entire_logs
                            .diffs_nav
                            .as_mut()
                            .and_then(|(nav_id_hash, nav)| {
                                (*nav_id_hash == id_hash).then_some(nav)
                            })
                        {
                            nav_scrollable::scroll_down(nav, delta)
                        };
                        (selection, Task::none())
                    } else {
                        let log_entry = log.get(log_ix).unwrap();
                        let file_ix =
                            if log_entry.file_paths.len().saturating_sub(1)
                                == file_ix
                            {
                                0
                            } else {
                                file_ix + 1
                            };

                        let (file, selection_task) = entire_log_file_selection(
                            entire_logs,
                            log_entry,
                            hash,
                            file_ix,
                        );
                        if let Some((nav_changes_hash, nav)) =
                            entire_logs.changes_nav.as_mut()
                            && *nav_changes_hash == hash
                        {
                            nav_scrollable::scroll_down_to_section(nav, file_ix)
                        };
                        let selection = LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(file),
                        };
                        (selection, selection_task)
                    }
                }
                None => {
                    if log.len().saturating_sub(1) == log_ix {
                        let ix = 0;
                        entire_log_selection(
                            nav,
                            entire_logs,
                            log,
                            ix,
                            VertDir::Up,
                        )
                    } else {
                        let ix = log_ix + 1;
                        entire_log_selection(
                            nav,
                            entire_logs,
                            log,
                            ix,
                            VertDir::Down,
                        )
                    }
                }
            }
        } else {
            let ix = 0;
            entire_log_selection(nav, entire_logs, log, ix, VertDir::Down)
        };
        state.view.entire_log = Some(selection);
        return task;

fn select_down(ctx: &mut Ctx<'_>, delta: Option<Duration>) -> Task<crate::Msg> {
    match ctx.state.primary {
        Primary::Status => select_down_status(ctx, delta),
        Primary::Channel => select_down_channel(ctx),
        Primary::EntireLog => select_down_entire_log(ctx, delta),

}

    let (selection, task) = match state.view.status.take() {

fn select_down_status(
    ctx: &mut Ctx<'_>,
    delta: Option<Duration>,
) -> Task<crate::Msg> {
    let (selection, task) = match ctx.state.status.take() {

                if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                ) {

                if let Some(nav) =
                    get_files_diffs_nav_mut(ctx.navigation, id_hash)
                {

            } else if repo_state.untracked_files.len().saturating_sub(1) == ix {

            } else if ctx.repo.untracked_files.len().saturating_sub(1) == ix {

                if !repo_state.changed_files.is_empty() {

                if !ctx.repo.changed_files.is_empty() {

                    changed_file_selection(
                        repo_state,
                        status_nav,
                        ix,
                        files,
                        files_diffs,
                        VertDir::Down,
                    )
                } else if !repo_state.log.is_empty() {

                    changed_file_selection(ix, VDir::Down, ctx)
                } else if !ctx.repo.short_log.is_empty() {

                    status_log_selection(
                        status_nav,
                        status_logs,
                        repo_state,
                        ix,
                        VertDir::Down,
                    )

                    status_log_selection(ix, VDir::Down, ctx)

                    untracked_file_selection(
                        repo_state,
                        status_nav,
                        ix,
                        files,
                        files_diffs,
                        VertDir::Up,
                    )

                    untracked_file_selection(ix, VDir::Up, ctx)