use crate::remote::CS;

        sender: Option<tokio::sync::oneshot::Sender<Option<(u64, Merkle)>>>,

        sender: Option<tokio::sync::oneshot::Sender<Option<(u64, Merkle, Merkle)>>>,

        sender: Option<tokio::sync::mpsc::Sender<Hash>>,

        sender: Option<tokio::sync::mpsc::Sender<CS>>,

        hashes: Vec<libpijul::pristine::Hash>,

        hashes: Vec<CS>,

                        debug!("s = {:?}", s);
                        if let (Some(n), Some(m)) = (s.next(), s.next()) {

                        if let (Some(n), Some(m), Some(m2)) = (s.next(), s.next(), s.next()) {

                                .send(Some((n, Merkle::from_base32(m.trim().as_bytes()).unwrap())))

                                .send(Some((
                                    n,
                                    Merkle::from_base32(m.trim().as_bytes()).unwrap(),
                                    Merkle::from_base32(m2.trim().as_bytes()).unwrap(),
                                )))

                            libpijul::changestore::filesystem::push_filename(
                                final_path,
                                &hashes[*current],
                            );
                            final_path.set_extension("change");
                            debug!("moving {:?} to {:?}", path, final_path);
                            std::fs::create_dir_all(&final_path.parent().unwrap())?;
                            let r = std::fs::rename(&path, &final_path);
                            libpijul::changestore::filesystem::pop_filename(final_path);
                            r?;

                            match hashes[*current] {
                                CS::Change(ref h) => {
                                    libpijul::changestore::filesystem::push_filename(final_path, h);
                                    debug!("moving {:?} to {:?}", path, final_path);
                                    std::fs::create_dir_all(&final_path.parent().unwrap())?;
                                    let r = std::fs::rename(&path, &final_path);
                                    libpijul::changestore::filesystem::pop_filename(final_path);
                                    r?;
                                }
                                CS::State(h) => {
                                    libpijul::changestore::filesystem::push_tag_filename(
                                        final_path, &h,
                                    );
                                    debug!("moving {:?} to {:?}", path, final_path);
                                    std::fs::create_dir_all(&final_path.parent().unwrap())?;
                                    let r = std::fs::rename(&path, &final_path);
                                    libpijul::changestore::filesystem::pop_filename(final_path);
                                    r?;
                                }
                            }

    ) -> Result<Option<(u64, Merkle)>, anyhow::Error> {

    ) -> Result<Option<(u64, Merkle, Merkle)>, anyhow::Error> {

                super::ListLine::Change { n, h, m, is_tagged } => f(a, n, h, m, is_tagged)?,

                super::ListLine::Change { n, h, m, tag } => f(a, n, h, m, tag)?,

        changes: &[Hash],

        changes: &[CS],

            libpijul::changestore::filesystem::push_filename(&mut local, &c);
            let mut change_file = std::fs::File::open(&local)?;
            let change_len = change_file.metadata()?.len();
            let mut change = thrussh::CryptoVec::new_zeroed(change_len as usize);
            use std::io::Read;
            change_file.read_exact(&mut change[..])?;

            self.c
                .data(format!("apply {} {} {}\n", to_channel, c.to_base32(), change_len).as_bytes())
                .await?;
            self.c.data(&change[..]).await?;
            libpijul::changestore::filesystem::pop_filename(&mut local);

            match c {
                CS::Change(c) => {
                    libpijul::changestore::filesystem::push_filename(&mut local, &c);
                    let mut change_file = std::fs::File::open(&local)?;
                    let change_len = change_file.metadata()?.len();
                    let mut change = thrussh::CryptoVec::new_zeroed(change_len as usize);
                    use std::io::Read;
                    change_file.read_exact(&mut change[..])?;
                    self.c
                        .data(
                            format!("apply {} {} {}\n", to_channel, c.to_base32(), change_len)
                                .as_bytes(),
                        )
                        .await?;
                    self.c.data(&change[..]).await?;
                    libpijul::changestore::filesystem::pop_filename(&mut local);
                }
                CS::State(c) => {
                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = libpijul::tag::OpenTagFile::open(&local, &c)?;
                    let mut v = Vec::new();
                    tag_file.short(&mut v)?;
                    self.c
                        .data(
                            format!("tagup {} {} {}\n", c.to_base32(), to_channel, v.len())
                                .as_bytes(),
                        )
                        .await?;
                    self.c.data(&v[..]).await?;
                    libpijul::changestore::filesystem::pop_filename(&mut local);
                }
            }

        c: &mut tokio::sync::mpsc::UnboundedReceiver<libpijul::pristine::Hash>,
        sender: &mut tokio::sync::mpsc::Sender<libpijul::pristine::Hash>,

        c: &mut tokio::sync::mpsc::UnboundedReceiver<CS>,
        sender: &mut tokio::sync::mpsc::Sender<CS>,

        c: &mut tokio::sync::mpsc::UnboundedReceiver<libpijul::pristine::Hash>,
        sender: Option<&mut tokio::sync::mpsc::Sender<libpijul::pristine::Hash>>,

        c: &mut tokio::sync::mpsc::UnboundedReceiver<CS>,
        sender: Option<&mut tokio::sync::mpsc::Sender<CS>>,

            if full {
                self.c
                    .data(format!("change {}\n", h.to_base32()).as_bytes())
                    .await?;
            } else {
                self.c
                    .data(format!("partial {}\n", h.to_base32()).as_bytes())
                    .await?;

            match h {
                CS::Change(h) if full => {
                    self.c
                        .data(format!("change {}\n", h.to_base32()).as_bytes())
                        .await?;
                }
                CS::Change(h) => {
                    self.c
                        .data(format!("partial {}\n", h.to_base32()).as_bytes())
                        .await?;
                }
                CS::State(h) => {
                    self.c
                        .data(format!("tag {}\n", h.to_base32()).as_bytes())
                        .await?;
                }

}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CS {
    Change(Hash),
    State(Merkle),

    pub to_upload: Vec<Hash>,
    pub remote_unrecs: Vec<(u64, Hash)>,
    pub unknown_changes: Vec<Hash>,

    pub to_upload: Vec<CS>,
    pub remote_unrecs: Vec<(u64, CS)>,
    pub unknown_changes: Vec<CS>,

    pub to_download: Vec<Hash>,
    pub tags: HashSet<Merkle>,

    pub to_download: Vec<CS>,

    pub ours_ge_dichotomy_set: HashSet<Hash>,
    pub theirs_ge_dichotomy_set: HashSet<Hash>,

    pub ours_ge_dichotomy_set: HashSet<CS>,
    pub theirs_ge_dichotomy_set: HashSet<CS>,

    pub remote_unrecs: Vec<(u64, Hash)>,

    pub remote_unrecs: Vec<(u64, CS)>,

        let mut to_upload = Vec::<Hash>::new();

        let mut to_upload = Vec::new();

                        to_upload.push(h.into())

                        to_upload.push(CS::Change(h.into()))

                                to_upload.push(h.into());

                                to_upload.push(CS::Change(h.into()));

        let mut to_upload = Vec::<Hash>::new();

        let mut to_upload = Vec::new();

            let mut tags: HashSet<Merkle> = HashSet::new();
            for x in txn.rev_iter_tags(&channel.read().tags, None)? {
                let (n, m) = x?;
                debug!("rev_iter_tags {:?} {:?}", n, m);
                // First, if the remote has exactly the same first n tags, break.
                if let Some((_, p)) = txn.get_remote_tag(&remote_ref.lock().tags, (*n).into())? {
                    if p.b == m.b {
                        debug!("the remote has tag {:?}", p.a);
                        break;
                    }
                    if p.a != m.a {
                        // What to do here?  It is possible that state
                        // `n` is a different state than `m.a` in the
                        // remote, and is also tagged.
                    }
                } else {
                    tags.insert(m.a.into());
                }
            }
            debug!("tags = {:?}", tags);

                if txn.remote_has_state(remote_ref, &m)? {
                    break;

                let h_unrecorded = self
                    .remote_unrecs
                    .iter()
                    .any(|(_, hh)| hh == &CS::Change(h.into()));
                if !h_unrecorded {
                    if txn.remote_has_state(remote_ref, &m)?.is_some() {
                        debug!("remote_has_state: {:?}", m);
                        break;
                    }

                if !txn.remote_has_change(remote_ref, &h)?
                    && !self.theirs_ge_dichotomy_set.contains(&h_deser)

                if (!txn.remote_has_change(remote_ref, &h)? || h_unrecorded)
                    && !self.theirs_ge_dichotomy_set.contains(&CS::Change(h_deser))

                        to_upload.push(h_deser)

                        if tags.remove(&m.into()) {
                            to_upload.push(CS::State(m.into()));
                        }
                        to_upload.push(CS::Change(h_deser));

                                to_upload.push(h_deser);

                                to_upload.push(CS::Change(h_deser));
                                if tags.remove(&m.into()) {
                                    to_upload.push(CS::State(m.into()));
                                }

                }
            }
            for t in tags.iter() {
                if let Some(n) = txn.remote_has_state(&remote_ref, &t.into())? {
                    if !txn.is_tagged(&remote_ref.lock().tags, n)? {
                        to_upload.push(CS::State(*t));
                    }
                } else {
                    debug!("the remote doesn't have state {:?}", t);

        let unknown_changes = self
            .theirs_ge_dichotomy
            .iter()
            .filter_map(|(_, h, _, _)| {
                if self.ours_ge_dichotomy_set.contains(h)
                    || txn.get_revchanges(&channel, h).unwrap().is_some()

        let mut unknown_changes = Vec::new();
        for (_, h, m, is_tag) in self.theirs_ge_dichotomy.iter() {
            let h_is_known = txn.get_revchanges(&channel, h).unwrap().is_some();
            let change = CS::Change(*h);
            if !(self.ours_ge_dichotomy_set.contains(&change) || h_is_known) {
                unknown_changes.push(change)
            }
            if *is_tag {
                let m_is_known = if let Some(n) = txn
                    .channel_has_state(txn.states(&*channel.read()), &m.into())
                    .unwrap()

                    None

                    txn.is_tagged(txn.tags(&*channel.read()), n.into()).unwrap()

                    Some(*h)

                    false
                };
                if !m_is_known {
                    unknown_changes.push(CS::State(*m))

            })
            .collect::<Vec<Hash>>();

            }
        }

                to_download.push(h);

                to_download.push(CS::Change(h));

            tags: HashSet::new(),

        let mut tags = HashSet::new();

                let (n, (h, m)) = x?;

                let (_, (h, m)) = x?;

                        to_download.push(h.into());
                        if txn.is_tagged(&remote_channel.tags, n)? {
                            tags.insert(m.into());
                        }

                        to_download.push(CS::Change(h.into()));

            tags,

        let n = self
            .dichotomy_changelist(txn, &remote.lock().remote)
            .await?;

        let n = self.dichotomy_changelist(txn, &remote.lock()).await?;

        }
        let v: Vec<_> = txn
            .iter_tags(&remote.lock().tags, n)?
            .filter_map(|k| {
                debug!("filter_map {:?}", k);
                let k = (*k.unwrap().0).into();
                if k >= n {
                    Some(k)
                } else {
                    None
                }
            })
            .collect();
        for k in v {
            debug!("deleting {:?}", k);
            txn.del_tags(&mut remote.lock().tags, k)?;

    }
    async fn update_changelist_pushpull_from_scratch(
        &mut self,
        txn: &mut MutTxn<()>,
        path: &[String],
        current_channel: &ChannelRef<MutTxn<()>>,
    ) -> Result<RemoteDelta<MutTxn<()>>, anyhow::Error> {
        debug!("no id, starting from scratch");
        let (inodes, theirs_ge_dichotomy) = self.download_changelist_nocache(0, path).await?;
        let mut theirs_ge_dichotomy_set = HashSet::new();
        let mut to_download = Vec::new();
        for (_, h, m, is_tag) in theirs_ge_dichotomy.iter() {
            theirs_ge_dichotomy_set.insert(CS::Change(*h));
            if txn.get_revchanges(current_channel, h)?.is_none() {
                to_download.push(CS::Change(*h));
            }
            if *is_tag {
                let ch = current_channel.read();
                if let Some(n) = txn.channel_has_state(txn.states(&*ch), &m.into())? {
                    if !txn.is_tagged(txn.tags(&*ch), n.into())? {
                        to_download.push(CS::State(*m));
                    }
                } else {
                    to_download.push(CS::State(*m));
                }
            }
        }
        Ok(RemoteDelta {
            inodes,
            remote_ref: None,
            to_download,
            ours_ge_dichotomy_set: HashSet::new(),
            theirs_ge_dichotomy,
            theirs_ge_dichotomy_set,
            remote_unrecs: Vec::new(),
        })

        is_tag: bool,

            debug!("no id, starting from scratch");
            let (inodes, theirs_ge_dichotomy) = self.download_changelist_nocache(0, path).await?;
            let mut theirs_ge_dichotomy_set = HashSet::new();
            let mut to_download = Vec::new();
            let mut tags = HashSet::new();
            for (_, h, m, is_tagged) in theirs_ge_dichotomy.iter() {
                theirs_ge_dichotomy_set.insert(*h);
                if txn.get_revchanges(current_channel, h)?.is_none() {
                    to_download.push(*h);
                    if *is_tagged {
                        tags.insert(*m);
                    }
                }
            }
            return Ok(RemoteDelta {
                inodes,
                remote_ref: None,
                to_download,
                tags,
                ours_ge_dichotomy_set: HashSet::new(),
                theirs_ge_dichotomy,
                theirs_ge_dichotomy_set,
                remote_unrecs: Vec::new(),
            });
        };
        let mut remote_ref = if let Some(name) = self.name() {
            txn.open_or_create_remote(id, name).unwrap()
        } else {
            unreachable!()

            return self
                .update_changelist_pushpull_from_scratch(txn, path, current_channel)
                .await;

        let dichotomy_n = self
            .dichotomy_changelist(txn, &remote_ref.lock().remote)
            .await?;
        let ours_ge_dichotomy: Vec<(u64, Hash)> = txn

        let mut remote_ref = txn.open_or_create_remote(id, self.name().unwrap()).unwrap();
        let dichotomy_n = self.dichotomy_changelist(txn, &remote_ref.lock()).await?;
        let ours_ge_dichotomy: Vec<(u64, CS)> = txn

                            Some((k, hash))

                            Some((k, CS::Change(hash)))

        debug!("theirs_ge_dichotomy = {:?}", theirs_ge_dichotomy);

            .copied()
            .collect::<HashSet<Hash>>();
        let theirs_ge_dichotomy_set = theirs_ge_dichotomy
            .iter()
            .map(|(_, h, _, _)| h)

            .collect::<HashSet<Hash>>();
        // remote_unrecs = {x: (u64, Hash) | x \in ours_ge_dichot /\ ~(x \in theirs_ge_dichot) /\ x \in current_channel }
        let mut remote_unrecs = Vec::new();
        for (n, hash) in &ours_ge_dichotomy {
            if theirs_ge_dichotomy_set.contains(hash) {
                // If this change is still present in the remote, skip
                continue;
            } else if txn.get_revchanges(&current_channel, &hash)?.is_none() {
                // If this unrecord wasn't in our current channel, skip
                continue;
            } else {
                remote_unrecs.push((*n, *hash))

            .collect::<HashSet<CS>>();
        let mut theirs_ge_dichotomy_set = HashSet::new();
        for (_, h, m, is_tag) in theirs_ge_dichotomy.iter() {
            theirs_ge_dichotomy_set.insert(CS::Change(*h));
            if *is_tag {
                theirs_ge_dichotomy_set.insert(CS::State(*m));

        let should_cache = force_cache.unwrap_or_else(|| remote_unrecs.is_empty());

        // remote_unrecs = {x: (u64, Hash) | x \in ours_ge_dichot /\ ~(x \in theirs_ge_dichot) /\ x \in current_channel }
        let remote_unrecs = remote_unrecs(
            txn,
            current_channel,
            &ours_ge_dichotomy,
            &theirs_ge_dichotomy_set,
        )?;
        let should_cache = if let Some(true) = force_cache {
            true
        } else {
            remote_unrecs.is_empty()
        };
        debug!(
            "should_cache = {:?} {:?} {:?}",
            force_cache, remote_unrecs, should_cache
        );

            for (k, _) in ours_ge_dichotomy.iter().copied() {
                txn.del_remote(&mut remote_ref, k)?;

            use libpijul::ChannelMutTxnT;
            for (k, t) in ours_ge_dichotomy.iter().copied() {
                match t {
                    CS::State(_) => txn.del_tags(&mut remote_ref.lock().tags, k)?,
                    CS::Change(_) => {
                        txn.del_remote(&mut remote_ref, k)?;
                    }
                }

            for (n, h, m, t) in theirs_ge_dichotomy.iter().copied() {
                txn.put_remote(&mut remote_ref, n, (h, m, t))?;

            for (n, h, m, is_tag) in theirs_ge_dichotomy.iter().copied() {
                debug!("theirs: {:?} {:?} {:?}", n, h, m);
                txn.put_remote(&mut remote_ref, n, (h, m))?;
                if is_tag {
                    txn.put_tags(&mut remote_ref.lock().tags, n, &m)?;
                }

        let state_cond = |txn: &MutTxn<()>, merkle: &libpijul::pristine::SerializedMerkle| {
            txn.channel_has_state(txn.states(&*current_channel.read()), merkle)
                .map(|x| x.is_some())
        };
        let change_cond = |txn: &MutTxn<()>, hash: &Hash| {
            txn.get_revchanges(&current_channel, hash)
                .unwrap()
                .is_none()
        };
        // IF:
        //     The user only wanted to push/pull specific changes
        // ELIF:
        //     The user specified no changes and there were no remote unrecords
        //     effecting the current channel means we can auto-cache
        //     the local remote cache
        // ELSE:
        //     The user specified no changes but there were remote unrecords
        //     effecting the current channel meaning we can't auto-cache
        //     the local remote cache.

            // Here, the user only wanted to push/pull specific changes

                .map(|h| Ok(txn.hash_from_prefix(h)?.0))

                .map(|h| {
                    if is_tag {
                        Ok(CS::State(
                            txn.state_from_prefix(&*current_channel.read(), h)?.0,
                        ))
                    } else {
                        Ok(CS::Change(txn.hash_from_prefix(h)?.0))
                    }
                })

                tags: HashSet::new(),

        } else if should_cache {
            let mut to_download: Vec<Hash> = Vec::new();
            let mut tags = HashSet::new();
            {
                let rem = remote_ref.lock();
                for thing in txn.iter_remote(&rem.remote, 0)? {
                    let (n, libpijul::pristine::Pair { a: hash, b: merkle }) = thing?;
                    if state_cond(txn, &merkle)? {
                        break;
                    } else if change_cond(txn, &hash.into()) {
                        to_download.push(Hash::from(hash));
                        if txn.is_tagged(&rem.tags, (*n).into())? {
                            tags.insert(merkle.into());
                        }

        } else {
            let mut to_download: Vec<CS> = Vec::new();
            for (n, h, m, is_tag) in theirs_ge_dichotomy.iter() {
                // In all cases, add this new change/state/tag to `to_download`.
                let ch = CS::Change(*h);
                if txn.get_revchanges(&current_channel, h).unwrap().is_none() {
                    to_download.push(ch.clone());
                    if *is_tag {
                        to_download.push(CS::State(*m));

                }
            }
            Ok(RemoteDelta {
                inodes,
                remote_ref: Some(remote_ref),
                to_download,
                tags,
                ours_ge_dichotomy_set,
                theirs_ge_dichotomy,
                theirs_ge_dichotomy_set,
                remote_unrecs,
            })
        } else {
            let mut to_download: Vec<Hash> = Vec::new();
            for thing in txn.iter_remote(&remote_ref.lock().remote, 0)? {
                let (n, libpijul::pristine::Pair { a: hash, b: merkle }) = thing?;
                if u64::from(*n) < dichotomy_n {
                    if state_cond(txn, &merkle)? {
                        continue;
                    } else if change_cond(txn, &hash.into()) {
                        to_download.push(Hash::from(hash));

                } else if *is_tag {
                    let has_tag = if let Some(n) =
                        txn.channel_has_state(txn.states(&current_channel.read()), &m.into())?
                    {
                        txn.is_tagged(txn.tags(&current_channel.read()), n.into())?
                    } else {
                        false
                    };
                    if !has_tag {
                        to_download.push(CS::State(*m));

            }
            let mut tags = HashSet::new();
            for (_, hash, merkle, t) in &theirs_ge_dichotomy {
                if state_cond(txn, &merkle.into())? {
                    continue;
                } else if change_cond(txn, &hash) {
                    to_download.push(Hash::from(*hash));
                    if *t {
                        tags.insert(*merkle);

                // Additionally, if there are no remote unrecords
                // (i.e. if `should_cache`), cache.
                if should_cache && ours_ge_dichotomy_set.get(&ch).is_none() {
                    use libpijul::ChannelMutTxnT;
                    txn.put_remote(&mut remote_ref, *n, (*h, *m))?;
                    if *is_tag {
                        let mut rem = remote_ref.lock();
                        txn.put_tags(&mut rem.tags, *n, m)?;

                tags,

        let f = |v: &mut Vec<(u64, Hash, Merkle, bool)>, n, h, m, t| {

        let f = |v: &mut Vec<(u64, Hash, Merkle, bool)>, n, h, m, m2| {

            Ok(v.push((n, h, m, t)))

            Ok(v.push((n, h, m, m2)))

        remote: &T::Remote,

        remote: &libpijul::pristine::Remote<T>,

        let (mut b, state): (_, Merkle) = if let Some((u, v)) = txn.last_remote(remote)? {

        let (mut b, state): (_, Merkle) = if let Some((u, v)) = txn.last_remote(&remote.remote)? {

        if let Some((_, s)) = self.get_state(txn, Some(b)).await? {
            if s == state {

        let last_statet = if let Some((_, _, v)) = txn.last_remote_tag(&remote.tags)? {
            v.into()
        } else {
            Merkle::zero()
        };
        debug!("last_state: {:?} {:?}", state, last_statet);
        if let Some((_, s, st)) = self.get_state(txn, Some(b)).await? {
            debug!("remote last_state: {:?} {:?}", s, st);
            if s == state && st == last_statet {

            let (mid, state) = txn.get_remote_state(remote, mid)?.unwrap();

            let (mid, state) = {
                let (a, b) = txn.get_remote_state(&remote.remote, mid)?.unwrap();
                (a, b.b)
            };
            let statet = if let Some((_, b)) = txn.get_remote_tag(&remote.tags, mid)? {
                // There's still a tag at position >= mid in the
                // sequence.
                b.b.into()
            } else {
                // No tag at or after mid, the last state, `statet`,
                // is the right answer in that case.
                last_statet
            };

            if let Some((_, remote_state)) = remote_state {
                if remote_state == state.b {

            if let Some((_, remote_state, remote_statet)) = remote_state {
                if remote_state == state && remote_statet == statet {

    ) -> Result<Option<(u64, Merkle)>, anyhow::Error> {

    ) -> Result<Option<(u64, Merkle, Merkle)>, anyhow::Error> {

        let f = |a: &mut (&mut T, &mut RemoteRef<T>), n, h, m, is_tagged| {

        let f = |a: &mut (&mut T, &mut RemoteRef<T>), n, h, m, is_tag| {

            txn.put_remote(remote, n, (h, m, is_tagged))?;

            txn.put_remote(remote, n, (h, m))?;
            if is_tag {
                txn.put_tags(&mut remote.lock().tags, n, &m.into())?;
            }

        changes: &[Hash],

        changes: &[CS],

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<libpijul::pristine::Hash>,
        send: &mut tokio::sync::mpsc::Sender<libpijul::pristine::Hash>,

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<CS>,
        send: &mut tokio::sync::mpsc::Sender<CS>,

        to_apply: &[Hash],

        to_apply: &[CS],

    ) -> Result<Vec<Hash>, anyhow::Error> {

    ) -> Result<Vec<CS>, anyhow::Error> {

            libpijul::changestore::filesystem::push_filename(&mut change_path_, h);
            if std::fs::metadata(&change_path_).is_err() {
                hash_send.send(*h)?;
                to_download.insert(*h);

            if let CS::Change(h) = h {
                libpijul::changestore::filesystem::push_filename(&mut change_path_, h);
                if std::fs::metadata(&change_path_).is_err() {
                    hash_send.send(CS::Change(*h))?;
                    to_download.insert(CS::Change(*h));
                }
                libpijul::changestore::filesystem::pop_filename(&mut change_path_);

            libpijul::changestore::filesystem::pop_filename(&mut change_path_);

                    let changes = repo.changes.get_changes(h)?;
                    changes.iter().any(|c| {
                        c.iter().any(|c| {
                            let inode = c.inode();
                            debug!("inode = {:?}", inode);
                            if let Some(h) = inode.change {
                                inodes.contains(&Position {
                                    change: h,
                                    pos: inode.pos,
                                })
                            } else {
                                false
                            }

                    if let CS::Change(h) = h {
                        let changes = repo.changes.get_changes(h)?;
                        changes.iter().any(|c| {
                            c.iter().any(|c| {
                                let inode = c.inode();
                                debug!("inode = {:?}", inode);
                                if let Some(h) = inode.change {
                                    inodes.contains(&Position {
                                        change: h,
                                        pos: inode.pos,
                                    })
                                } else {
                                    false
                                }
                            })

                    })

                    } else {
                        false
                    }

                || { inodes.iter().any(|i| i.change == *h) };

                || { inodes.iter().any(|i| CS::Change(i.change) == *h) };

                let mut channel = channel.write();
                txn.apply_change_ws(&repo.changes, &mut channel, h, &mut ws)?;

                if let CS::Change(h) = h {
                    let mut channel = channel.write();
                    txn.apply_change_ws(&repo.changes, &mut channel, h, &mut ws)?;
                }

            send_hash.send(h)?;

            send_hash.send(CS::Change(h))?;

            libpijul::changestore::filesystem::push_filename(&mut change_path, &hash);
            std::fs::create_dir_all(change_path.parent().unwrap())?;
            use libpijul::changestore::ChangeStore;
            hashes.push(hash);
            for dep in repo.changes.get_dependencies(&hash)? {
                let dep: libpijul::pristine::Hash = dep;
                send_hash.send(dep)?;

            if let CS::Change(hash) = hash {
                libpijul::changestore::filesystem::push_filename(&mut change_path, &hash);
                std::fs::create_dir_all(change_path.parent().unwrap())?;
                use libpijul::changestore::ChangeStore;
                hashes.push(CS::Change(hash));
                for dep in repo.changes.get_dependencies(&hash)? {
                    let dep: libpijul::pristine::Hash = dep;
                    send_hash.send(CS::Change(dep))?;
                }
                libpijul::changestore::filesystem::pop_filename(&mut change_path);

            libpijul::changestore::filesystem::pop_filename(&mut change_path);

                txn.apply_change_ws(&repo.changes, &mut channel_, hash, &mut ws)?;

                if let CS::Change(hash) = hash {
                    txn.apply_change_ws(&repo.changes, &mut channel_, hash, &mut ws)?;
                }

            to_pull.push(p.a.into());

            to_pull.push(CS::Change(p.a.into()));

        changes: &[Hash],

        changes: &[CS],

            let c = if let CS::Change(c) = c {
                c
            } else {
                unreachable!()
            };

                send_hash.send(*c)?;

                send_hash.send(CS::Change(*c))?;

                    send_hash.send(*c)?;

                    send_hash.send(CS::Change(*c))?;

                pullable.push(p.a.into())

                pullable.push(CS::Change(p.a.into()))

        is_tagged: bool,

        tag: bool,

                is_tagged: caps.name("tag").is_some(),

                tag: caps.name("tag").is_some(),

}
/// Compare the remote set (theirs_ge_dichotomy) with our current
/// version of that (ours_ge_dichotomy) and return the changes in our
/// current version that are not in the remote anymore.
fn remote_unrecs<T: TxnTExt + ChannelTxnT>(
    txn: &T,
    current_channel: &ChannelRef<T>,
    ours_ge_dichotomy: &[(u64, CS)],
    theirs_ge_dichotomy_set: &HashSet<CS>,
) -> Result<Vec<(u64, CS)>, anyhow::Error> {
    let mut remote_unrecs = Vec::new();
    for (n, hash) in ours_ge_dichotomy {
        debug!("ours_ge_dichotomy: {:?} {:?}", n, hash);
        if theirs_ge_dichotomy_set.contains(hash) {
            // If this change is still present in the remote, skip
            debug!("still present");
            continue;
        } else {
            let has_it = match hash {
                CS::Change(hash) => txn.get_revchanges(&current_channel, &hash)?.is_some(),
                CS::State(state) => {
                    let ch = current_channel.read();
                    if let Some(n) = txn.channel_has_state(txn.states(&*ch), &state.into())? {
                        txn.is_tagged(txn.tags(&*ch), n.into())?
                    } else {
                        false
                    }
                }
            };
            if has_it {
                remote_unrecs.push((*n, *hash))
            } else {
                // If this unrecord wasn't in our current channel, skip
                continue;
            }
        }
    }
    Ok(remote_unrecs)

use crate::remote::CS;

) -> Result<Option<(u64, Merkle)>, anyhow::Error> {
    if let Some(mid) = mid {
        Ok(txn.get_changes(&channel, mid)?.map(|(_, m)| (mid, m)))

) -> Result<Option<(u64, Merkle, Merkle)>, anyhow::Error> {
    if let Some(x) = txn.reverse_log(&*channel.read(), mid)?.next() {
        let (n, (_, m)) = x?;
        if let Some(m2) = txn
            .rev_iter_tags(txn.tags(&*channel.read()), Some(n.into()))?
            .next()
        {
            let (_, m2) = m2?;
            Ok(Some((n, m.into(), m2.b.into())))
        } else {
            Ok(Some((n, m.into(), Merkle::zero())))
        }

        Ok(txn.reverse_log(&*channel.read(), None)?.next().map(|n| {
            let (n, (_, m)) = n.unwrap();
            (n, m.into())
        }))

        Ok(None)

    pub fn get_state(&mut self, mid: Option<u64>) -> Result<Option<(u64, Merkle)>, anyhow::Error> {

    pub fn get_state(
        &mut self,
        mid: Option<u64>,
    ) -> Result<Option<(u64, Merkle, Merkle)>, anyhow::Error> {

        for x in remote_txn.log(&*remote_channel.read(), from)? {

        let rem = remote_channel.read();
        let tags: Vec<u64> = remote_txn
            .iter_tags(remote_txn.tags(&*rem), from)?
            .map(|k| (*k.unwrap().0).into())
            .collect();
        let mut tagsi = 0;
        for x in remote_txn.log(&*rem, from)? {

                f(
                    a,
                    n,
                    h.into(),
                    m.into(),
                    remote_txn.is_tagged(&remote_channel.read().tags, n)?,
                )?;

                if tags.get(tagsi) == Some(&n) {
                    f(a, n, h.into(), m.into(), true)?;
                    tagsi += 1;
                } else {
                    f(a, n, h.into(), m.into(), false)?;
                }

        changes: &[Hash],

        changes: &[CS],

            libpijul::changestore::filesystem::push_filename(&mut local, &c);
            libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);

            match c {
                CS::Change(c) => {
                    libpijul::changestore::filesystem::push_filename(&mut local, &c);
                    libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);
                }
                CS::State(c) => {
                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    libpijul::changestore::filesystem::push_tag_filename(&mut self.changes_dir, &c);
                }
            }

            debug!("hard link done");
            libpijul::changestore::filesystem::pop_filename(&mut local);
            libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<libpijul::pristine::Hash>,
        send: &mut tokio::sync::mpsc::Sender<libpijul::pristine::Hash>,

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<CS>,
        send: &mut tokio::sync::mpsc::Sender<CS>,

            libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);
            libpijul::changestore::filesystem::push_filename(&mut path, &c);
            super::PROGRESS.borrow_mut().unwrap()[pro_n].incr();
            if std::fs::metadata(&path).is_ok() {
                debug!("metadata {:?} ok", path);

            if let CS::Change(c) = c {
                libpijul::changestore::filesystem::push_filename(&mut self.changes_dir, &c);
                libpijul::changestore::filesystem::push_filename(&mut path, &c);
                super::PROGRESS.borrow_mut().unwrap()[pro_n].incr();
                if std::fs::metadata(&path).is_ok() {
                    debug!("metadata {:?} ok", path);
                    libpijul::changestore::filesystem::pop_filename(&mut path);
                    continue;
                }
                std::fs::create_dir_all(&path.parent().unwrap())?;
                if std::fs::hard_link(&self.changes_dir, &path).is_err() {
                    std::fs::copy(&self.changes_dir, &path)?;
                }
                debug!("hard link done");
                libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);

                continue;
            }
            std::fs::create_dir_all(&path.parent().unwrap())?;
            if std::fs::hard_link(&self.changes_dir, &path).is_err() {
                std::fs::copy(&self.changes_dir, &path)?;

            debug!("hard link done");
            libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);
            libpijul::changestore::filesystem::pop_filename(&mut path);

    changes: &[Hash],

    changes: &[CS],

        txn.apply_change_ws(store, &mut *channel, c, &mut ws)?;

        match c {
            CS::Change(c) => {
                txn.apply_change_ws(store, &mut *channel, c, &mut ws)?;
            }
            CS::State(c) => {
                if let Some(n) = txn.channel_has_state(txn.states(&*channel), &c.into())? {
                    let tags = txn.tags_mut(&mut *channel);
                    txn.put_tags(tags, n.into(), c)?;
                } else {
                    bail!(
                        "Cannot add tag {}: channel {:?} does not have that state",
                        c.to_base32(),
                        txn.name(&*channel)
                    )
                }
            }
        }

            debug!("hard link done");
            libpijul::changestore::filesystem::pop_filename(&mut local);
            libpijul::changestore::filesystem::pop_filename(&mut self.changes_dir);

use crate::remote::CS;

    c: libpijul::pristine::Hash,
) -> Result<libpijul::pristine::Hash, anyhow::Error> {
    libpijul::changestore::filesystem::push_filename(&mut path, &c);

    c: CS,
) -> Result<CS, anyhow::Error> {
    let (req, c32) = match c {
        CS::Change(c) => {
            libpijul::changestore::filesystem::push_filename(&mut path, &c);
            ("change", c.to_base32())
        }
        CS::State(c) => {
            libpijul::changestore::filesystem::push_tag_filename(&mut path, &c);
            if std::fs::metadata(&path).is_ok() {
                bail!("Tag already downloaded: {}", c.to_base32())
            }
            ("tag", c.to_base32())
        }
    };

    libpijul::changestore::filesystem::pop_filename(&mut path);
    let c32 = c.to_base32();

            .query(&[("change", &c32)])

            .query(&[(req, &c32)])

        std::fs::rename(&path_, &path_.with_extension("change"))?;

        match c {
            CS::Change(_) => {
                std::fs::rename(&path_, &path)?;
            }
            CS::State(_) => {
                std::fs::rename(&path_, &path)?;
            }
        }

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<libpijul::pristine::Hash>,
        send: &mut tokio::sync::mpsc::Sender<libpijul::pristine::Hash>,

        hashes: &mut tokio::sync::mpsc::UnboundedReceiver<CS>,
        send: &mut tokio::sync::mpsc::Sender<CS>,

        changes: &[libpijul::Hash],

        changes: &[CS],

            libpijul::changestore::filesystem::push_filename(&mut local, &c);

            let change = std::fs::read(&local)?;

            let c = c.to_base32();
            to_channel.push(("apply", &c));

            let base32;
            let body = match c {
                CS::Change(c) => {
                    libpijul::changestore::filesystem::push_filename(&mut local, &c);
                    let change = std::fs::read(&local)?;
                    base32 = c.to_base32();
                    to_channel.push(("apply", &base32));
                    change
                }
                CS::State(c) => {
                    libpijul::changestore::filesystem::push_tag_filename(&mut local, &c);
                    let mut tag_file = libpijul::tag::OpenTagFile::open(&local, &c)?;
                    let mut v = Vec::new();
                    tag_file.short(&mut v)?;
                    base32 = c.to_base32();
                    to_channel.push(("tagup", &base32));
                    v
                }
            };
            libpijul::changestore::filesystem::pop_filename(&mut local);

                .body(change)

                .body(body)

            libpijul::changestore::filesystem::pop_filename(&mut local);

                        super::ListLine::Change { n, m, h, is_tagged } => f(a, n, h, m, is_tagged)?,

                        super::ListLine::Change { n, m, h, tag } => f(a, n, h, m, tag)?,

    ) -> Result<Option<(u64, libpijul::Merkle)>, anyhow::Error> {

    ) -> Result<Option<(u64, libpijul::Merkle, libpijul::Merkle)>, anyhow::Error> {

        if let (Some(n), Some(m)) = (

        if let (Some(n), Some(m), Some(m2)) = (

            s.next()
                .and_then(|m| libpijul::Merkle::from_base32(m.as_bytes())),

            Ok(Some((n, m)))

            Ok(Some((n, m, m2)))

use crate::remote::CS;
use crate::repository::Repository;

use crate::repository::Repository;

                .map(|h| (h.unwrap().1).0.into())

                .map(|h| CS::Change((h.unwrap().1).0.into()))

                hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))

                if let CS::Change(h) = h {
                    hashes.push((*h, *txn.get_internal(&h.into())?.unwrap()))
                }

    #[clap(long = "repository")]
    repo_path: Option<PathBuf>,
    #[clap(long = "channel")]
    channel: Option<String>,

                let repo = Repository::find_root(None)?;

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

                let channel_name = txn
                    .current_channel()
                    .unwrap_or(crate::DEFAULT_CHANNEL)
                    .to_string();

                let channel_name = self.channel.unwrap_or_else(|| {
                    txn.current_channel()
                        .unwrap_or(crate::DEFAULT_CHANNEL)
                        .to_string()
                });

                    let t = (*t?).into();
                    let (_, m) = txn.get_changes(&channel, t)?.unwrap();

                    let (t, _) = t?;
                    let (_, m) = txn.get_changes(&channel, (*t).into())?.unwrap();

use crate::remote::{PushDelta, RemoteDelta, RemoteRepo};

use crate::remote::{PushDelta, RemoteDelta, RemoteRepo, CS};

    /// Push tags instead of regular changes.
    #[clap(long = "tag")]
    is_tag: bool,

    /// Pull tags instead of regular changes.
    #[clap(long = "tag")]
    is_tag: bool,

        is_tag: bool,

                is_tag,

            .to_upload(&mut *txn.write(), &mut channel, &repo, &mut remote)

            .to_upload(
                &mut *txn.write(),
                &mut channel,
                &repo,
                &mut remote,
                self.is_tag,
            )

            let mut u: Vec<libpijul::Hash> = Vec::new();

            let mut u: Vec<CS> = Vec::new();

                        if to_upload.contains(&hash) {
                            u.push(hash);

                        if to_upload.contains(&CS::Change(hash)) {
                            u.push(CS::Change(hash));

            u.sort_by(|a, b| {
                let na = txn.get_revchanges(&channel, a).unwrap().unwrap();
                let nb = txn.get_revchanges(&channel, b).unwrap().unwrap();
                na.cmp(&nb)

            u.sort_by(|a, b| match (a, b) {
                (CS::Change(a), CS::Change(b)) => {
                    let na = txn.get_revchanges(&channel, a).unwrap().unwrap();
                    let nb = txn.get_revchanges(&channel, b).unwrap().unwrap();
                    na.cmp(&nb)
                }
                (CS::State(a), CS::State(b)) => {
                    let na = txn
                        .channel_has_state(txn.states(&*channel.read()), &a.into())
                        .unwrap()
                        .unwrap();
                    let nb = txn
                        .channel_has_state(txn.states(&*channel.read()), &b.into())
                        .unwrap()
                        .unwrap();
                    na.cmp(&nb)
                }
                _ => unreachable!(),

        is_tag: bool,

                is_tag,

            tags,

            .to_download(&mut *txn.write(), &mut channel, &mut repo, &mut remote)

            .to_download(
                &mut *txn.write(),
                &mut channel,
                &mut repo,
                &mut remote,
                self.is_tag,
            )

                txn.apply_change_rec_ws(&repo.changes, &mut channel, h, &mut ws)?;

                match h {
                    CS::Change(h) => {
                        txn.apply_change_rec_ws(&repo.changes, &mut channel, h, &mut ws)?;
                    }
                    CS::State(s) => {
                        if let Some(n) = txn.channel_has_state(&channel.states, &s.into())? {
                            txn.put_tags(&mut channel.tags, n.into(), s)?;
                        } else {
                            bail!(
                                "Cannot add tag {}: channel {:?} does not have that state",
                                s.to_base32(),
                                channel.name
                            )
                        }
                    }
                }

            if let Some(int) = txn_.get_internal(&d.into())? {
                for inode in txn_.iter_rev_touched(int)? {
                    let (int_, inode) = inode?;
                    if int_ < int {
                        continue;
                    } else if int_ > int {
                        break;
                    }
                    let ext = libpijul::pristine::Position {
                        change: txn_.get_external(&inode.change)?.unwrap().into(),
                        pos: inode.pos,
                    };
                    if inodes.is_empty() || inodes.contains(&ext) {
                        touched.insert(*inode);

            match d {
                CS::Change(d) => {
                    if let Some(int) = txn_.get_internal(&d.into())? {
                        for inode in txn_.iter_rev_touched(int)? {
                            let (int_, inode) = inode?;
                            if int_ < int {
                                continue;
                            } else if int_ > int {
                                break;
                            }
                            let ext = libpijul::pristine::Position {
                                change: txn_.get_external(&inode.change)?.unwrap().into(),
                                pos: inode.pos,
                            };
                            if inodes.is_empty() || inodes.contains(&ext) {
                                touched.insert(*inode);
                            }
                        }

                }
                CS::State(_) => {
                    // No need to do anything for now here, we don't
                    // output after downloading a tag.

            if touched_paths.is_empty() {

            if touched_paths.is_empty() && !self.is_tag {

    original: &[libpijul::Hash],
    now: &[libpijul::Hash],
) -> Result<Vec<libpijul::Hash>, anyhow::Error> {

    original: &[CS],
    now: &[CS],
) -> Result<Vec<CS>, anyhow::Error> {

        for d in c.get_dependencies(&h)? {
            if original.get(&d).is_some() && now_.get(&d).is_none() {

        let hh = if let CS::Change(h) = h {
            h
        } else {
            stack.pop();
            result.push(h);
            continue;
        };
        for d in c.get_dependencies(&hh)? {
            if original.get(&CS::Change(d)).is_some() && now_.get(&CS::Change(d)).is_none() {

                stack.push(d);

                stack.push(CS::Change(d));

fn check_deps<C: ChangeStore>(
    c: &C,
    original: &[libpijul::Hash],
    now: &[libpijul::Hash],
) -> Result<(), anyhow::Error> {

fn check_deps<C: ChangeStore>(c: &C, original: &[CS], now: &[CS]) -> Result<(), anyhow::Error> {

        let n = if let CS::Change(n) = n { n } else { continue };

            if original_.get(&d).is_some() && now_.get(&d).is_none() {

            if original_.get(&CS::Change(d)).is_some() && now_.get(&CS::Change(d)).is_none() {

fn notify_remote_unrecords(repo: &Repository, remote_unrecs: &[(u64, Hash)]) {

fn notify_remote_unrecords(repo: &Repository, remote_unrecs: &[(u64, crate::remote::CS)]) {

            let header = &repo.changes.get_change(hash).unwrap().header;

            let header = match hash {
                CS::Change(hash) => repo.changes.get_header(hash).unwrap(),
                CS::State(hash) => repo.changes.get_tag_header(hash).unwrap(),
            };

            writeln!(&mut s, "#    {}", header.message).expect("Infallible write to String");
            writeln!(&mut s, "#    {}", header.timestamp).expect("Infallible write to String");
            writeln!(&mut s, "#    {}", hash.to_base32()).expect("Infallible write to String");

            writeln!(&mut s, "#    {}", header.message).unwrap();
            writeln!(&mut s, "#    {}", header.timestamp).unwrap();
            match hash {
                CS::Change(hash) => {
                    writeln!(&mut s, "#    {}", hash.to_base32()).unwrap();
                }
                CS::State(hash) => {
                    writeln!(&mut s, "#    {}", hash.to_base32()).unwrap();
                }
            }

fn notify_unknown_changes(unknown_changes: &[Hash]) {

fn notify_unknown_changes(unknown_changes: &[crate::remote::CS]) {

            writeln!(&mut s, "#     {}", hash.to_base32()).expect("Infallible write to String");

            let hash = match hash {
                CS::Change(hash) => hash.to_base32(),
                CS::State(hash) => hash.to_base32(),
            };
            writeln!(&mut s, "#     {}", hash).expect("Infallible write to String");

    static ref TAG: Regex = Regex::new(r#"^tag\s+(\S+)\s+(\S+)\s+([0-9]+)\s+"#).unwrap();

    static ref TAG: Regex = Regex::new(r#"^tag\s+(\S+)\s+"#).unwrap();
    static ref TAGUP: Regex = Regex::new(r#"^tagup\s+(\S+)\s+(\S+)\s+([0-9]+)\s+"#).unwrap();

                    for x in txn.read().log(&*channel.read(), pos)? {

                    let txn = txn.read();
                    for x in txn.log(&*channel.read(), pos)? {

                                writeln!(o, "{} {}", n, m.to_base32())?;

                                let m2 = if let Some(x) = txn
                                    .rev_iter_tags(txn.tags(&*channel.read()), Some(n))?
                                    .next()
                                {
                                    x?.1.b.into()
                                } else {
                                    Merkle::zero()
                                };
                                writeln!(o, "{} {} {}", n, m.to_base32(), m2.to_base32())?;

                } else if let Some(x) = txn.read().reverse_log(&*channel.read(), None)?.next() {
                    let (n, (_, m)) = x?;
                    let m: Merkle = m.into();
                    writeln!(o, "{} {}", n, m.to_base32())?

                    writeln!(o, "-")?;

                    let txn = txn.read();
                    if let Some(x) = txn.reverse_log(&*channel.read(), None)?.next() {
                        let (n, (_, m)) = x?;
                        let m: Merkle = m.into();
                        let m2 = if let Some(x) = txn
                            .rev_iter_tags(txn.tags(&*channel.read()), Some(n))?
                            .next()
                        {
                            x?.1.b.into()
                        } else {
                            Merkle::zero()
                        };
                        writeln!(o, "{} {} {}", n, m.to_base32(), m2.to_base32())?
                    } else {
                        writeln!(o, "-")?;
                    }

                let tags: Vec<u64> = txn
                    .iter_tags(txn.tags(&*channel.read()), from)?
                    .map(|k| (*k.unwrap().0).into())
                    .collect();
                let mut tagsi = 0;

                        if txn.is_tagged(&channel.read().tags, n)? {
                            writeln!(o, "{}.{}.{}.", n, h.to_base32(), m.to_base32())?

                        if paths.is_empty() && tags.get(tagsi) == Some(&n) {
                            writeln!(o, "{}.{}.{}.", n, h.to_base32(), m.to_base32(),)?;
                            tagsi += 1;

                            writeln!(o, "{}.{}.{}", n, h.to_base32(), m.to_base32())?

                            writeln!(o, "{}.{}.{}", n, h.to_base32(), m.to_base32())?;

                    let mut tag_path = repo.changes_dir.clone();
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &state);
                    let mut tag = libpijul::tag::OpenTagFile::open(&tag_path, &state)?;
                    let mut buf = Vec::new();
                    tag.short(&mut buf)?;
                    o.write_u64::<BigEndian>(buf.len() as u64)?;
                    o.write_all(&buf)?;
                    o.flush()?;
                }
            } else if let Some(cap) = TAGUP.captures(&buf) {
                if let Some(state) = Merkle::from_base32(cap[1].as_bytes()) {

                        let mut tag_path = repo.changes_dir.clone();
                        libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &m);
                        if std::fs::metadata(&tag_path).is_ok() {
                            bail!("Tag for state {} already exists", m.to_base32());
                        }

                        let mut tag_path = repo.changes_dir.clone();
                        std::fs::create_dir_all(&tag_path)?;
                        let mut temp_path = tag_path.clone();
                        temp_path.push("tmp");
                        let mut w = std::fs::File::create(&temp_path)?;

                        let header = bincode::deserialize(&buf)?;

                        let header = libpijul::tag::read_short(std::io::Cursor::new(&buf[..]), &m)?;
                        let temp_path = tag_path.with_extension("tmp");
                        std::fs::create_dir_all(temp_path.parent().unwrap())?;
                        let mut w = std::fs::File::create(&temp_path)?;

                        libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &m);
                        std::fs::create_dir_all(tag_path.parent().unwrap())?;

use crate::remote::CS;

    pullable: &[libpijul::Hash],

    pullable: &[CS],

        writeln!(v, "{}\n", p.to_base32()).unwrap();
        let deps = changes.get_dependencies(&p)?;
        if !deps.is_empty() {
            write!(v, "  Dependencies:").unwrap();
            for d in deps {
                write!(v, " {}", d.to_base32()).unwrap();

        let header = match p {
            CS::Change(p) => {
                writeln!(v, "{}\n", p.to_base32()).unwrap();
                let deps = changes.get_dependencies(&p)?;
                if !deps.is_empty() {
                    write!(v, "  Dependencies:").unwrap();
                    for d in deps {
                        write!(v, " {}", d.to_base32()).unwrap();
                    }
                    writeln!(v).unwrap();
                }
                changes.get_header(&p)?
            }
            CS::State(p) => {
                writeln!(v, "t{}\n", p.to_base32()).unwrap();
                changes.get_tag_header(&p)?

            writeln!(v).unwrap();
        }
        let change = changes.get_header(&p)?;

        };

        for a in change.authors.iter() {

        for a in header.authors.iter() {

        writeln!(v, "  Date: {}\n", change.timestamp).unwrap();
        for l in change.message.lines() {

        writeln!(v, "  Date: {}\n", header.timestamp).unwrap();
        for l in header.message.lines() {

        if let Some(desc) = change.description {

        if let Some(desc) = header.description {

fn parse_changelist(o: &[u8]) -> Vec<libpijul::Hash> {

fn parse_changelist(o: &[u8]) -> Vec<crate::remote::CS> {

            .filter_map(|l| libpijul::Hash::from_base32(l.as_bytes()))

            .filter_map(|l| {
                ::log::debug!(
                    "l = {:?} {:?}",
                    l,
                    libpijul::Merkle::from_base32(l.as_bytes())
                );
                if l.starts_with("t") {
                    libpijul::Merkle::from_base32(&l.as_bytes()[1..]).map(crate::remote::CS::State)
                } else {
                    libpijul::Hash::from_base32(l.as_bytes()).map(crate::remote::CS::Change)
                }
            })

    pub fn short<W: std::io::Write>(&mut self, mut w: W) -> Result<(), TagError> {
        let mut header_buf = vec![0u8; (self.header.channel - self.header.header) as usize];
        self.file.seek(SeekFrom::Start(self.header.header))?;
        self.file.read_exact(&mut header_buf)?;
        debug!("header_buf = {:?}", header_buf);
        let mut off = FileHeader {
            version: VERSION,
            header: 0,
            channel: 0,
            unhashed: 0,
            total: 0,
            offsets: DbOffsets::default(),
            state: self.header.state.clone(),
        };
        off.header = bincode::serialized_size(&off)?;
        off.channel = off.header + header_buf.len() as u64;
        off.total = off.channel;
        let mut off_buf = Vec::with_capacity(off.header as usize);
        bincode::serialize_into(&mut off_buf, &off)?;
        w.write_all(&off_buf)?;
        w.write_all(&header_buf)?;
        Ok(())
    }
}
pub fn read_short<R: std::io::Read + std::io::Seek>(mut file: R, expected: &Merkle) -> Result<crate::change::ChangeHeader, TagError> {
    let mut off = [0u8; std::mem::size_of::<FileHeader>() as usize];
    file.seek(SeekFrom::Start(0))?;
    file.read_exact(&mut off)?;
    let header: FileHeader = bincode::deserialize(&off).map_err(TagError::BincodeDe)?;
    debug!("header = {:?}", header);
    if &header.state == expected {
        file.seek(SeekFrom::Start(header.header))?;
        Ok(bincode::deserialize_from(file).map_err(TagError::BincodeDe)?)
    } else {
        Err(TagError::WrongHash {
            expected: *expected,
            got: header.state,
        })
    }

    let tags = copy::<L64, Pair<SerializedMerkle, SerializedMerkle>, UP<L64, Pair<SerializedMerkle, SerializedMerkle>>, _>(

    debug!("copying tags");
    let tags = copy::<L64, Pair<SerializedMerkle, SerializedMerkle>, P<L64, Pair<SerializedMerkle, SerializedMerkle>>, _>(

    type Changeset = u64; // Db<ChangeId, L64>;
    type RevChangeset = u64; // UDb<L64, Pair<ChangeId, SerializedMerkle>>;
    type Tags = u64; // UDb<L64, SerializedHash>;

    type Changeset = u64;
    type RevChangeset = u64;
    type Tags = u64;

    type States = u64; // UDb<SerializedMerkle, L64>;

    type States = u64;

        ::sanakirja::btree::cursor::Cursor<L64, (), P<L64, ()>>;

        ::sanakirja::btree::cursor::Cursor<L64, Pair<SerializedMerkle, SerializedMerkle>, P<L64, Pair<SerializedMerkle, SerializedMerkle>>>;

        let db: Db<L64, ()> = Db::from_page(*tags);

        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*tags);

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

        let db: Db<L64, ()> = Db::from_page(*channel);

        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

            Ok(x.map(|(a, _)| a))

            Ok(x)

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

            Ok(x.map(|(a, _)| a))

            Ok(x)

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

        let db: Db<L64, ()> = Db::from_page(*channel);

        let db: Db<L64, Pair<SerializedMerkle, SerializedMerkle>> = Db::from_page(*channel);

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

            Ok(x.map(|(a, _)| a))

            Ok(x)

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>> {

            Ok(x.map(|(a, _)| a))

            Ok(x)

    ) -> Result<super::Cursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>

    ) -> Result<super::Cursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>, TxnErr<Self::GraphError>>

    ) -> Result<super::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>

    ) -> Result<super::RevCursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>, TxnErr<Self::GraphError>>

    fn state_from_prefix(
        &self,
        channel: &Self::Channel,
        s: &str,
    ) -> Result<(Merkle, L64), super::HashPrefixError<Self::GraphError>> {
        let h: SerializedMerkle = if let Some(ref h) = Merkle::from_prefix(s) {
            h.into()
        } else {
            return Err(super::HashPrefixError::Parse(s.to_string()));
        };
        let mut result = None;
        debug!("h = {:?}", h);
        for x in btree::iter(&self.txn, &channel.states, Some((&h, None)))
            .map_err(|e| super::HashPrefixError::Txn(e.into()))?
        {
            let (e, i) = x.map_err(|e| super::HashPrefixError::Txn(e.into()))?;
            debug!("{:?} {:?}", e, i);
            if e < &h {
                continue;
            } else {
                let e: Merkle = e.into();
                let b32 = e.to_base32();
                debug!("{:?}", b32);
                let (b32, _) = b32.split_at(s.len().min(b32.len()));
                if b32 != s {
                    break;
                } else if result.is_none() {
                    result = Some((e, *i))
                } else {
                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));
                }
            }
        }
        if let Some(result) = result {
            Ok(result)
        } else {
            Err(super::HashPrefixError::NotFound(s.to_string()))
        }
    }

    sanakirja_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    sanakirja_rev_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    type RemotetagsCursor = ::sanakirja::btree::cursor::Cursor<
        L64,
        Pair<SerializedMerkle, SerializedMerkle>,
        UP<L64, Pair<SerializedMerkle, SerializedMerkle>>,
    >;

        debug!("last_remote: {:?}", remote);

        remote: &Self::Remotetags,

        remote: &Self::Tags,

    }
    fn get_remote_tag(
        &self,
        remote: &Self::Tags,
        n: u64,
    ) -> Result<Option<(u64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>>
    {
        let n = n.into();
        if let Some(x) = btree::rev_iter(&self.txn, remote, Some((&n, None)))?.next() {
            let (&k, m) = x?;
            Ok(Some((k.into(), m)))
        } else {
            Ok(None)
        }

    ) -> Result<bool, TxnErr<Self::GraphError>> {

    ) -> Result<Option<u64>, TxnErr<Self::GraphError>> {

            Some((k, _)) if k == m => Ok(true),
            _ => Ok(false),

            Some((k, v)) if k == m => Ok(Some((*v).into())),
            _ => Ok(None),

        debug!("del_changes {:?} {:?}", t_, p);

        debug!("del_tags {:?} {:?}", t_, p);

        v: (Hash, Merkle, bool),

        v: (Hash, Merkle),

        debug!("remote.remote after put: {:?}", remote.remote);

        if v.2 {
            self.put_tags(&mut remote.tags, k, &v.1)?;
        }

        // if v.2 {
        //     self.put_tags(&mut remote.tags, k, &v.1)?;
        // }

            _tags: r.tags.db.into(),

const REMOTE_LEN: usize = 40;

        33 + self.path.len()

        REMOTE_LEN + 1 + self.path.len()

        33 + (*p.add(32)) as usize

        REMOTE_LEN + 1 + (*p.add(REMOTE_LEN)) as usize

        let len = *p.add(32) as usize;

        let len = *p.add(REMOTE_LEN) as usize;

            33 + self.path.len(),

            REMOTE_LEN + 1 + self.path.len(),

            std::slice::from_raw_parts(p, 33 + self.path.len())

            std::slice::from_raw_parts(p, REMOTE_LEN + 1 + self.path.len())

    _tags: L64,

        let len = 33 + self._path.len() as usize;

        let len = REMOTE_LEN + 1 + self._path.len() as usize;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(fmt, "{}", data_encoding::BASE32_NOPAD.encode(&self.0))
    }
}
impl std::fmt::Debug for RemoteId {

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>>;

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>>;

    ) -> Result<Option<(&L64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

    ) -> Result<Cursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>;

    ) -> Result<Cursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>, TxnErr<Self::GraphError>>;

        RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

        RevCursor<Self, &Self, Self::TagsCursor, L64, Pair<SerializedMerkle, SerializedMerkle>>,

    fn state_from_prefix(
        &self,
        channel: &Self::Channel,
        s: &str,
    ) -> Result<(Merkle, L64), HashPrefixError<Self::GraphError>>;

    cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);
    rev_cursor!(remotetags, L64, Pair<SerializedMerkle, SerializedMerkle>);

        remote: &Self::Remotetags,

        remote: &Self::Tags,

    /// Find the last state greater than or equal to n.

    /// Find the last tag less than or equal to n (opposite of get_remote_state).
    fn get_remote_tag(
        &self,
        remote: &Self::Tags,
        n: u64,
    ) -> Result<Option<(u64, &Pair<SerializedMerkle, SerializedMerkle>)>, TxnErr<Self::GraphError>>;

    ) -> Result<bool, TxnErr<Self::GraphError>>;

    ) -> Result<Option<u64>, TxnErr<Self::GraphError>>;

initialized_cursor!(tags, L64, Pair<SerializedMerkle, SerializedMerkle>, ChannelTxnT, GraphError);
initialized_rev_cursor!(tags, L64, Pair<SerializedMerkle, SerializedMerkle>, ChannelTxnT, GraphError);

impl<'a, T: ChannelTxnT> Iterator for crate::pristine::RevCursor<T, &'a T, T::TagsCursor, L64, ()>
{
    type Item = Result<&'a L64, TxnErr<T::GraphError>>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.txn.cursor_tags_prev(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok(x)),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}

impl<'a, T: ChannelTxnT>
    crate::pristine::Cursor<T, &'a T, T::TagsCursor, L64, ()>
{
    pub fn prev(&mut self) -> Option<Result<u64, TxnErr<T::GraphError>>> {
        match self.txn.cursor_tags_prev(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok((*x).into())),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}
impl<'a, T: ChannelTxnT> Iterator for crate::pristine::Cursor<T, &'a T, T::TagsCursor, L64, ()>
{
    type Item = Result<u64, TxnErr<T::GraphError>>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.txn.cursor_tags_next(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok((*x).into())),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}

        v: (Hash, Merkle, bool),

        v: (Hash, Merkle),