use anyhow::bail;

use libpijul::{MutTxnT, MutTxnTExt, TxnT};

use libpijul::changestore::ChangeStore;
use libpijul::{Base32, MutTxnT, MutTxnTExt, TxnT};

    /// Undo the change in the working copy (preserving unrecorded changes if there are any)
    #[clap(long = "reset")]
    reset: bool,

        let repo = Repository::find_root(self.repo_path)?;

        let mut repo = Repository::find_root(self.repo_path)?;

            let pending_hash = if self.reset {
                super::pending(&mut txn, &mut channel, &mut repo)?
            } else {
                None
            };

                        return Err((crate::Error::CannotUnrecord {
                            change: c,
                            dep: txn.get_external(d).unwrap(),
                        })
                        .into());

                        let dep = txn.get_external(d).unwrap();
                        if Some(dep) == pending_hash {
                            bail!(
                                "Cannot unrecord change {} because unrecorded changes depend on it",
                                c
                            );
                        } else {
                            bail!(
                                "Cannot unrecord change {} because {} depend on it",
                                c,
                                dep.to_base32()
                            );
                        }

            if let Some(h) = pending_hash {
                txn.output_repository_no_pending(
                    &mut repo.working_copy,
                    &repo.changes,
                    &mut channel,
                    "",
                    true,
                )?;
                txn.unrecord(&repo.changes, &mut channel, &h)?;
                repo.changes.del_change(&h)?;
            }

        let recorded = txn.record_all(
            libpijul::Algorithm::default(),
            &mut channel,
            &mut repo.working_copy,
            &repo.changes,
            "",
        )?;
        let hash = if recorded.actions.is_empty() {
            None
        } else {
            let actions = recorded
                .actions
                .into_iter()
                .map(|rec| rec.globalize(&txn))
                .collect();
            let mut pending_change = libpijul::change::Change::make_change(
                &txn,
                &channel,
                actions,
                recorded.contents,
                libpijul::change::ChangeHeader::default(),
                Vec::new(),
            );
            let (dependencies, extra_known) =
                libpijul::change::dependencies(&txn, &channel, pending_change.changes.iter());
            pending_change.dependencies = dependencies;
            pending_change.extra_known = extra_known;
            let hash = repo.changes.save_change(&pending_change).unwrap();
            txn.apply_local_change(&mut channel, &pending_change, hash, &recorded.updatables)?;
            Some(hash)
        };

        let hash = super::pending(&mut txn, &mut channel, &mut repo)?;

/// Record the pending change (i.e. any unrecorded modifications in
/// the working copy), returning its hash.
fn pending<T: libpijul::MutTxnTExt + libpijul::TxnT>(
    txn: &mut T,
    channel: &mut libpijul::ChannelRef<T>,
    repo: &mut crate::repository::Repository,
) -> Result<Option<libpijul::Hash>, anyhow::Error> {
    use libpijul::changestore::ChangeStore;
    let recorded = txn.record_all(
        libpijul::Algorithm::default(),
        channel,
        &mut repo.working_copy,
        &repo.changes,
        "",
    )?;
    if recorded.actions.is_empty() {
        return Ok(None);
    }
    let actions = recorded
        .actions
        .into_iter()
        .map(|rec| rec.globalize(txn))
        .collect();
    let mut pending_change = libpijul::change::Change::make_change(
        txn,
        channel,
        actions,
        recorded.contents,
        libpijul::change::ChangeHeader::default(),
        Vec::new(),
    );
    let (dependencies, extra_known) =
        libpijul::change::dependencies(txn, channel, pending_change.changes.iter());
    pending_change.dependencies = dependencies;
    pending_change.extra_known = extra_known;
    let hash = repo.changes.save_change(&pending_change).unwrap();
    txn.apply_local_change(channel, &pending_change, hash, &recorded.updatables)?;
    Ok(Some(hash))
}