use std::path::{Path, PathBuf};

/// Get the path to the repo
pub fn repo_path(repo: &PijulRepo) -> PathBuf {
    let PijulRepo {
        rootdir: dir,
        subdir,
    } = repo;
    if let Some(subdir) = subdir {
        dir.path().join(subdir)
    } else {
        dir.path().to_path_buf()
    }
}

    let dir = tempdir().unwrap();

    setup_pijul_repo_in_subdir("")
}

    let repo =
        Repository::init(Some(dir.path().to_path_buf()), None, None).unwrap();

/// Setup an empty Pijul repo inside a given subdir in a temp dir
pub fn setup_pijul_repo_in_subdir<P: AsRef<Path>>(subdir: P) -> PijulRepo {
    let rootdir = tempdir().unwrap();
    let repo = Repository::init(Some(rootdir.path().join(&subdir)), None, None)
        .unwrap();

    PijulRepo { dir }

    PijulRepo {
        rootdir,
        subdir: if subdir.as_ref().as_os_str().is_empty() {
            None
        } else {
            Some(subdir.as_ref().to_path_buf())
        },
    }

    pub dir: TempDir,

    pub rootdir: TempDir,
    pub subdir: Option<PathBuf>,

#[cfg(test)]
mod test;

#[derive(Debug)]
pub enum LoadError {
    DoesntExist,
    NotPijulRepo,
    Inaccessible(std::io::Error),
}

    let (mut internal_state, state) =
        spawn_blocking(move || load(path)).await.unwrap();
    // dbg!(diff(&state.repo));

    match spawn_blocking(move || load(path)).await.unwrap() {
        Ok((mut internal_state, state)) => {
            // dbg!(diff(&state.repo));

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

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

    while let Some(msg) = msg_in_rx.recv().await {
        info!("Repo received msg {msg}");
        internal_state = update(internal_state, msg, &msg_out_tx).await;

            while let Some(msg) = msg_in_rx.recv().await {
                info!("Repo received msg {msg}");
                internal_state = update(internal_state, msg, &msg_out_tx).await;
            }
        }
        Err(_err) => {
            // let _ = msg_out_tx.send(MsgOut::CannotLoad{err, msg_in_rx}));
        }

fn load(path: PathBuf) -> (InternalState, State) {
    let repo = pijul::Repository::find_root(Some(path)).unwrap();

fn load(path: PathBuf) -> Result<(InternalState, State), LoadError> {
    match std::fs::exists(&path) {
        Ok(true) => {}
        Ok(false) => return Err(LoadError::DoesntExist),
        Err(e) => return Err(LoadError::Inaccessible(e)),
    }
    let repo = pijul::Repository::find_root(Some(path))
        .map_err(|_e| LoadError::NotPijulRepo)?;

    (internal_state, state)

    Ok((internal_state, state))

    dbg!(&log);

use crate::repo;
use crate::testing::{repo_path, setup_pijul_repo, setup_pijul_repo_in_subdir};
use assert_matches::assert_matches;
use tempfile::tempdir;
#[test]
fn test_load_repo() {
    // Handle a non-existent path gracefully
    let dir = tempdir().unwrap();
    let result =
        repo::load(dir.path().join("howdoyouopensomethingthatdoesntexist"));
    assert!(result.is_err());
    assert_matches!(result.unwrap_err(), repo::LoadError::DoesntExist);
    // Handle a path without a pijul repo gracefully
    let dir = tempdir().unwrap();
    let result = repo::load(dir.path().to_path_buf());
    assert!(result.is_err());
    assert_matches!(result.unwrap_err(), repo::LoadError::NotPijulRepo);
    #[cfg(unix)]
    {
        // Handle an inaccessible path due to permissions gracefully
        let subdir = "inaccessible";
        let repo = setup_pijul_repo_in_subdir(subdir);
        let repo_path = repo_path(&repo);
        // Make the dir inaccessible
        std::fs::set_permissions(repo.rootdir.path(), <std::fs::Permissions as std::os::unix::fs::PermissionsExt>::from_mode(0o000)).unwrap();
        assert!(std::fs::exists(&repo_path).is_err());
        let result = repo::load(repo.rootdir.path().join(subdir).to_path_buf());
        assert!(result.is_err());
        assert_matches!(result.unwrap_err(), repo::LoadError::Inaccessible(_));
    }
    // A valid path with a repo
    let repo = setup_pijul_repo();
    let repo_path = repo_path(&repo);
    let (_internal, state) = repo::load(repo_path.clone()).unwrap();
    let repo::State {
        dir_name,
        channel,
        untracked_files,
        changed_files,
        log,
    } = state;
    assert_eq!(
        &dir_name,
        &repo_path
            .components()
            .last()
            .unwrap()
            .as_os_str()
            .to_string_lossy()
    );
    assert_eq!(&channel, libpijul::DEFAULT_CHANNEL);
    assert_eq!(untracked_files.len(), 1);
    assert!(untracked_files.contains(".ignore"));
    assert!(changed_files.is_empty());
    assert!(log.is_empty());
}

[dev-dependencies.assert_matches]
workspace = true

    setup_pijul_id, setup_pijul_repo, PijulId, PijulRepo,

    repo_path, setup_pijul_id, setup_pijul_repo, PijulId, PijulRepo,

    let repo_path = repo.dir.path();

    let repo_path = repo_path(&repo);

    let repo_path = repo.dir.path();

    let repo_path = repo_path(&repo);

    let repo_path = repo.dir.path();

    let repo_path = repo_path(&repo);

    let repo_path = repo.dir.path();

    let repo_path = repo_path(&repo);

 "assert_matches",