use iced::time::Instant;

    /// Directional key press
    PressDir(Dir),
    /// Directional key release
    ReleaseDir(Dir),
    /// Mouse select
    Select(Select),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Dir {

    Select(Select),

    /// Last directional key down that's not yet been released
    pub held_key: Option<HeldKey>,
}
#[derive(Debug)]
pub struct HeldKey {
    pub dir: Dir,
    pub last_tick: Instant,

            .on_press(Msg::Cursor(cursor::Msg::Left)))

            .on_press(Msg::Cursor(cursor::Msg::PressDir(cursor::Dir::Left))))

                .on_press(Msg::Cursor(cursor::Msg::Left)))

                .on_press(Msg::Cursor(
                    cursor::Msg::PressDir(cursor::Dir::Left),
                )))

    let cursor = cursor::State { selection: None };

    let cursor = cursor::State::default();

        held_key: None,

                &mut state.files_diffs,
                &mut state.logs,

                &state.files_diffs,
                &state.logs,

    use iced::keyboard::{key, on_key_press, Key, Modifiers};

    use iced::keyboard::{key, on_key_press, on_key_release, Key, Modifiers};

    let key_subs = on_key_press(|key, mods| {

    let key_press_subs = on_key_press(|key, mods| {

                    "j" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Down))),
                    "k" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Up))),
                    "h" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Left))),
                    "l" => {
                        Some(Msg::View(app::Msg::Cursor(cursor::Msg::Right)))
                    }

                    "j" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::PressDir(cursor::Dir::Down),
                    ))),
                    "k" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::PressDir(cursor::Dir::Up),
                    ))),
                    "h" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::PressDir(cursor::Dir::Left),
                    ))),
                    "l" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::PressDir(cursor::Dir::Right),
                    ))),

                Key::Named(key::Named::ArrowDown) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Down)))
                }
                Key::Named(key::Named::ArrowUp) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Up)))
                }
                Key::Named(key::Named::ArrowLeft) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Left)))
                }
                Key::Named(key::Named::ArrowRight) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Right)))
                }

                Key::Named(key::Named::ArrowDown) => Some(Msg::View(
                    app::Msg::Cursor(cursor::Msg::PressDir(cursor::Dir::Down)),
                )),
                Key::Named(key::Named::ArrowUp) => Some(Msg::View(
                    app::Msg::Cursor(cursor::Msg::PressDir(cursor::Dir::Up)),
                )),
                Key::Named(key::Named::ArrowLeft) => Some(Msg::View(
                    app::Msg::Cursor(cursor::Msg::PressDir(cursor::Dir::Left)),
                )),
                Key::Named(key::Named::ArrowRight) => Some(Msg::View(
                    app::Msg::Cursor(cursor::Msg::PressDir(cursor::Dir::Right)),
                )),

                Key::Named(_) | Key::Unidentified => None,
            }
        }
    });
    let key_release_subs = on_key_release(|key, mods| {
        if mods.is_empty() {
            match key {
                Key::Character(c) => match c.as_str() {
                    "j" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::ReleaseDir(cursor::Dir::Down),
                    ))),
                    "k" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::ReleaseDir(cursor::Dir::Up),
                    ))),
                    "h" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::ReleaseDir(cursor::Dir::Left),
                    ))),
                    "l" => Some(Msg::View(app::Msg::Cursor(
                        cursor::Msg::ReleaseDir(cursor::Dir::Right),
                    ))),
                    _ => None,
                },
                Key::Named(key::Named::ArrowDown) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::ReleaseDir(
                        cursor::Dir::Down,
                    ))))
                }
                Key::Named(key::Named::ArrowUp) => Some(Msg::View(
                    app::Msg::Cursor(cursor::Msg::ReleaseDir(cursor::Dir::Up)),
                )),
                Key::Named(key::Named::ArrowLeft) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::ReleaseDir(
                        cursor::Dir::Left,
                    ))))
                }
                Key::Named(key::Named::ArrowRight) => {
                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::ReleaseDir(
                        cursor::Dir::Right,
                    ))))
                }

        } else {
            None

    Subscription::batch([key_subs, window_subs, nav_subs])

    Subscription::batch([
        key_press_subs,
        key_release_subs,
        window_subs,
        nav_subs,
    ])

    LogChangeFileSelection, Msg, Select, Selection, State,

    Dir, HeldKey, LogChangeFileSelection, Msg, Select, Selection, State,

use libflorescence::repo;
use iced::time::{Duration, Instant};

use libflorescence::repo;

use std::cmp;

    files_diffs: &mut diff::FilesState,
    log_diffs: &mut diff::LogFilesAndState,

    files_diffs: &diff::FilesState,
    log_diffs: &diff::LogFilesAndState,

        Msg::Down => select_down(state, files, repo, files_diffs, log_diffs),
        Msg::Up => select_up(state, files, repo, files_diffs, log_diffs),
        Msg::Left => select_left(state, repo),
        Msg::Right => select_right(state, repo, files_diffs, log_diffs),

        Msg::PressDir(dir) => {
            let delta = state.held_key.as_ref().and_then(
                |HeldKey {
                     dir: held_dir,
                     last_tick,
                 }| {
                    (dir == *held_dir).then(|| {
                        // Ceil to 50 ms, because the first key repeat in Iced
                        // is delayed 500 ms and that creates too much of a jump
                        cmp::min(
                            Duration::from_millis(50),
                            Instant::now() - *last_tick,
                        )
                    })
                },
            );
            state.held_key = Some(HeldKey {
                dir,
                last_tick: Instant::now(),
            });
            match dir {
                Dir::Down => select_down(
                    state,
                    files,
                    repo,
                    files_diffs,
                    log_diffs,
                    delta,
                ),
                Dir::Up => {
                    select_up(state, files, repo, files_diffs, log_diffs, delta)
                }
                Dir::Left => select_left(state, repo),
                Dir::Right => select_right(state, repo, files_diffs, log_diffs),
            }
        }
        Msg::ReleaseDir(dir) => release(dir, state, files_diffs, log_diffs),

    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,

    files_diffs: &mut diff::FilesState,
    logs: &mut diff::LogFilesAndState,
    delta: Option<Duration>,

                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())

                            .get_mut(&id_hash)
                            .and_then(|state| state.nav.as_mut())

                            iced_nav_scrollable::scroll_down(nav)

                            iced_nav_scrollable::scroll_down(nav, delta)

                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())

                            .get_mut(&id_hash)
                            .and_then(|state| state.nav.as_mut())

                            iced_nav_scrollable::scroll_down(nav)

                            iced_nav_scrollable::scroll_down(nav, delta)

                                    .get(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_ref())

                                    .get_mut(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_mut())

                                    iced_nav_scrollable::scroll_down(nav)

                                    iced_nav_scrollable::scroll_down(nav, delta)

    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,

    files_diffs: &mut diff::FilesState,
    logs: &mut diff::LogFilesAndState,
    delta: Option<Duration>,

                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())

                            .get_mut(&id_hash)
                            .and_then(|state| state.nav.as_mut())

                            iced_nav_scrollable::scroll_up(nav)

                            iced_nav_scrollable::scroll_up(nav, delta)

                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())

                            .get_mut(&id_hash)
                            .and_then(|state| state.nav.as_mut())

                            iced_nav_scrollable::scroll_up(nav)

                            iced_nav_scrollable::scroll_up(nav, delta)

                                    .get(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_ref())

                                    .get_mut(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_mut())

                                    iced_nav_scrollable::scroll_up(nav)

                                    iced_nav_scrollable::scroll_up(nav, delta)

    }
}
fn release<M>(
    dir: Dir,
    state: &mut State,
    files_diffs: &mut diff::FilesState,
    log_diffs: &mut diff::LogFilesAndState,
) -> Task<M> {
    if state.held_key.as_ref().map(|key| key.dir) == Some(dir) {
        state.held_key = None;
        if let Dir::Down | Dir::Up = dir {
            match state.selection.as_mut() {
                Some(Selection::UntrackedFile {
                    ix: _,
                    path,
                    diff_selected: true,
                }) => {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Untracked);
                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {
                        nav.skip_delay = None;
                    }
                }
                Some(Selection::ChangedFile {
                    ix: _,
                    path,
                    diff_selected: true,
                }) => {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Changed);
                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {
                        nav.skip_delay = None;
                    }
                }
                Some(Selection::LogChange {
                    ix: _,
                    hash,
                    message: _,
                    file:
                        Some(LogChangeFileSelection {
                            ix: _,
                            path,
                            diff_selected: true,
                        }),
                }) => {
                    let id_hash = file::log_id_parts_hash(*hash, path);
                    if let Some(nav) = log_diffs
                        .diffs
                        .get_mut(&id_hash)
                        .and_then(|diff| diff.state.nav.as_mut())
                    {
                        nav.skip_delay = None;
                    }
                }
                Some(Selection::UntrackedFile { .. })
                | Some(Selection::ChangedFile { .. })
                | Some(Selection::LogChange { .. })
                | None => {}
            }
        }

    Task::none()

use iced::time::{Duration, Instant};

/// Default duration delta in milliseconds if the scroll key was not previously
/// held
const DEFAULT_DELTA: f32 = 30.0;
/// Scroll speed in pixels per second
const SPEED: f32 = 500.0;
/// Delay before skipping between sections while a scroll key is being held
const SKIP_DELAY_MS: u64 = 400;

    pub skip_delay: Option<SkipDelay>,
}
/// Delay that occurs when a scroll key is held before skipping to a next
/// section. Every time the skip delay is checked, time `left` is updated with
/// formula `left -= now - last_update`. When `left` reaches 0 the skip is
/// performed. If the scroll button is released, the skip delay is cleared until
/// next time.
///
/// A singular key press doesn't trigger skip delay, it only happens if it was
/// preceded by a non-skip scroll first and the key is continuously held.
#[derive(Debug)]
pub struct SkipDelay {
    /// Time when the last skip delay was updated.
    pub last_update: Instant,
    /// How much time is left before the skip can be performed
    pub left: Duration,
}
fn new_skip_delay() -> SkipDelay {
    let last_update = Instant::now();
    let left = Duration::from_millis(SKIP_DELAY_MS);
    SkipDelay { last_update, left }

            skip_delay: None,

// TODO: time delta
const DELTA: f32 = 10.0;

enum Delay {
    Start,
    Apply,
}

pub fn scroll_down<M>(nav: &NavScrollable) -> Task<M> {
    if let Some(y) = nav

pub fn scroll_down<M>(
    nav: &mut NavScrollable,
    delta: Option<Duration>,
) -> Task<M> {
    if let Some((y, delay)) = nav

                    Some(nav.offset + DELTA)

                    let offset_delta = delta
                        .map(|delta| delta.as_millis() as f32)
                        .unwrap_or(DEFAULT_DELTA)
                        / 1_000.0
                        * SPEED;
                    Some((nav.offset + offset_delta, Delay::Start))

                    Some(saturating_sub(*offset, VISIBLE_CONTEXT_HEIGHT))

                    Some((
                        saturating_sub(*offset, VISIBLE_CONTEXT_HEIGHT),
                        Delay::Apply,
                    ))

        match delay {
            Delay::Start => {
                nav.skip_delay = Some(new_skip_delay());
            }
            Delay::Apply => {
                if let Some(SkipDelay { last_update, left }) =
                    nav.skip_delay.as_mut()
                {
                    let now = Instant::now();
                    let delta = now - *last_update;
                    // Check if ready to skip
                    if delta >= *left {
                        // Prepare delay for the next one
                        nav.skip_delay = Some(new_skip_delay());
                    } else {
                        *last_update = Instant::now();
                        *left -= delta;
                        // Delay scrolling
                        return Task::none();
                    }
                } else {
                    // Prepare delay for the next one
                    nav.skip_delay = Some(new_skip_delay());
                }
            }
        }

pub fn scroll_up<M>(nav: &NavScrollable) -> Task<M> {
    if let Some(y) = nav

pub fn scroll_up<M>(
    nav: &mut NavScrollable,
    delta: Option<Duration>,
) -> Task<M> {
    if let Some((y, delay)) = nav

                    Some(saturating_sub(nav.offset, DELTA))
                } else if
                // offset + height < nav.offset &&
                offset + height

                    let offset_delta = delta
                        .map(|delta| delta.as_millis() as f32)
                        .unwrap_or(DEFAULT_DELTA)
                        / 1_000.0
                        * SPEED;
                    Some((
                        saturating_sub(nav.offset, offset_delta),
                        Delay::Start,
                    ))
                } else if offset + height

                    // Scroll to the bottom of the prev section
                    Some(saturating_sub(
                        offset + height + VISIBLE_CONTEXT_HEIGHT,
                        nav.height,

                    Some((
                        if *height
                            > nav.height
                                - VISIBLE_CONTEXT_HEIGHT
                                - VISIBLE_CONTEXT_HEIGHT
                        {
                            // The section doesn't fit within the frame, so
                            // scroll to the bottom of it
                            saturating_sub(
                                offset + height + VISIBLE_CONTEXT_HEIGHT,
                                nav.height,
                            )
                        } else {
                            // The section fits within the frame, so scroll to
                            // the top of it
                            saturating_sub(*offset, VISIBLE_CONTEXT_HEIGHT)
                        },
                        Delay::Apply,

        match delay {
            Delay::Start => {
                nav.skip_delay = Some(new_skip_delay());
            }
            Delay::Apply => {
                if let Some(SkipDelay { last_update, left }) =
                    nav.skip_delay.as_mut()
                {
                    let now = Instant::now();
                    let delta = now - *last_update;
                    // Check if ready to skip
                    if delta >= *left {
                        // Prepare delay for the next one
                        nav.skip_delay = Some(new_skip_delay());
                    } else {
                        *last_update = Instant::now();
                        *left -= delta;
                        // Delay scrolling
                        return Task::none();
                    }
                } else {
                    // Prepare delay for the next one
                    nav.skip_delay = Some(new_skip_delay());
                }
            }
        }