pub untracked_files: BTreeSet<String>,
    pub changed_files: ChangedFiles,
    pub log: Log,

    RefreshedState {
        untracked_files: BTreeSet<String>,
        changed_files: ChangedFiles,
        log: Log,
    },
    LogFileDiff {
        id: LogFileId,
        diffs: ChangedFile,
    },

    RefreshedState(State),
    LogFileDiff { id: LogFileId, diffs: ChangedFile },

    let mut state = spawn_blocking(move || load(path)).await.unwrap();

    let (mut internal_state, state) =
        spawn_blocking(move || load(path)).await.unwrap();

    let dir_name = dir_name(&state.repo).to_string();
    let channel = current_channel(&state.repo);
    let untracked_files = state.untracked_files.clone();
    let changed_files = state.changed_files.clone();
    let log = state.log.clone();

    let _ = msg_out_tx.send(MsgOut::Init(State {
        dir_name,
        channel,
        untracked_files,
        changed_files,
        log,
    }));

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

        state = update(state, msg, &msg_out_tx).await;

        internal_state = update(internal_state, msg, &msg_out_tx).await;

    mut state: InternalState,

    mut internal_state: InternalState,

            state = spawn_blocking(move || {
                refresh(&mut state);
                state

            let state: State;
            (internal_state, state) = spawn_blocking(move || {
                let state = get_state(&internal_state);
                (internal_state, state)

            let untracked_files = state.untracked_files.clone();
            let changed_files = state.changed_files.clone();
            let log = state.log.clone();
            let _ = msg_out_tx.send(MsgOut::RefreshedState {
                untracked_files,
                changed_files,
                log,
            });

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

            state = spawn_blocking(move || {
                add(&mut state, &path);
                state

            internal_state = spawn_blocking(move || {
                add(&mut internal_state, &path);
                internal_state

            state = spawn_blocking(move || {
                rm(&mut state, &path);
                state

            internal_state = spawn_blocking(move || {
                rm(&mut internal_state, &path);
                internal_state

            state = spawn_blocking(move || {
                record(&state, msg, sk);
                state

            internal_state = spawn_blocking(move || {
                record(&internal_state, msg, sk);
                internal_state

            (state, diffs) = spawn_blocking(move || {
                let change =
                    state.repo.changes.get_change(&change_hash).unwrap();

            (internal_state, diffs) = spawn_blocking(move || {
                let change = internal_state
                    .repo
                    .changes
                    .get_change(&change_hash)
                    .unwrap();

                    changed_files(&change, &state.repo.changes);

                    changed_files(&change, &internal_state.repo.changes);

                (state, diffs)

                (internal_state, diffs)

    state

    internal_state

fn load(path: PathBuf) -> InternalState {

fn load(path: PathBuf) -> (InternalState, State) {

    let diff = diff(&repo);
    let untracked_files = untracked_files(&repo);

    let internal_state = InternalState { repo };
    let state = get_state(&internal_state);
    (internal_state, state)
}
fn get_state(state: &InternalState) -> State {
    // TODO: Optimize by using the notify event info about what file has changed
    let repo = &state.repo;
    let dir_name = dir_name(repo).to_string();
    let channel = current_channel(repo);
    let diff = diff(repo);
    let untracked_files = untracked_files(repo);

    let log = log(&repo, offset, limit);
    InternalState {
        repo,

    let log = log(repo, offset, limit);
    State {
        dir_name,
        channel,

fn refresh(state: &mut InternalState) {
    // TODO: Optimize by using the notify event info about what file has changed
    state.untracked_files = untracked_files(state);
    let diff = diff(state);
    state.changed_files = changed_files(&diff, &state.repo.changes);
}

        repo::MsgOut::RefreshedState {
            untracked_files,
            changed_files,
            log,
        } => {
            let repo = state.repo.as_mut().unwrap();
            repo.untracked_files = untracked_files;
            repo.changed_files = changed_files;
            repo.log = log;

        repo::MsgOut::RefreshedState(repo_state) => {
            let repo::State {
                dir_name: _,
                channel: _,
                untracked_files,
                changed_files,
                log,
            } = &repo_state;

            if let Some(selection) = state.cursor.selection.take() {

            let task = if let Some(selection) = state.cursor.selection.take() {

                        let selection = repo
                            .untracked_files

                        let selection = untracked_files

                        if let Some(diffs) = repo.changed_files.get(&path) {

                        if let Some(diffs) = changed_files.get(&path) {

                        let selection = repo
                            .changed_files

                        let selection = changed_files

                        let (selection, task) = match repo
                            .log

                        let (selection, task) = match log

            }

            };
            state.repo = Some(repo_state);
            task