use std::collections::HashSet;

use libpijul::pristine::Position;

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

        sender: tokio::sync::mpsc::Sender<Option<super::ListLine>>,

                                let (n, h, m) = parse_line(l)?;
                                sender.send(Some((n, h, m))).await.unwrap_or(());

                                sender.send(parse_line(l).ok()).await.unwrap_or(())

    ) -> Result<(), anyhow::Error> {

    ) -> Result<HashSet<Position<Hash>>, anyhow::Error> {

            write!(command, " {}", p).unwrap()

            write!(command, " {:?}", p).unwrap()

        debug!("waiting ssh");
        while let Some(Some((n, h, m))) = receiver.recv().await {
            txn.put_remote(remote, n, (h, m))?;

        debug!("waiting ssh, command: {:?}", std::str::from_utf8(&command));
        let mut result = HashSet::new();
        while let Some(Some(m)) = receiver.recv().await {
            match m {
                super::ListLine::Change { n, h, m } => {
                    txn.put_remote(remote, n, (h, m))?;
                }
                super::ListLine::Position(pos) => {
                    result.insert(pos);
                }
            }

        debug!("no msg");
        Ok(())

        debug!("no msg, result = {:?}", result);
        Ok(result)

use std::collections::HashSet;

use anyhow::bail;

    ) -> Result<Option<RemoteRef<T>>, anyhow::Error> {

    ) -> Result<Option<(HashSet<Position<Hash>>, RemoteRef<T>)>, anyhow::Error> {

        self.download_changelist(txn, &mut remote, n, path).await?;

        let paths = self.download_changelist(txn, &mut remote, n, path).await?;

        Ok(Some(remote))

        Ok(Some((paths, remote)))

    ) -> Result<(), anyhow::Error> {

    ) -> Result<HashSet<Position<Hash>>, anyhow::Error> {

            RemoteRepo::Http(ref h) => {
                let url = h.url.clone() + "/" + DOT_DIR;
                let from_ = from.to_string();
                let mut query = vec![("changelist", &from_), ("channel", &h.channel)];
                for p in paths.iter() {
                    query.push(("path", p));
                }
                let res = h.client.get(&url).query(&query).send().await?;
                if !res.status().is_success() {
                    return Err((crate::Error::Http {
                        status: res.status(),
                    })
                    .into());
                }
                let resp = res.bytes().await?;
                if let Ok(data) = std::str::from_utf8(&resp) {
                    for l in data.lines() {
                        if !l.is_empty() {
                            let (n, h, m) = parse_line(l)?;
                            txn.put_remote(remote, n, (h, m))?;
                        } else {
                            break;
                        }
                    }
                }
                Ok(())
            }
            RemoteRepo::LocalChannel(_) => Ok(()),

            RemoteRepo::Http(ref h) => h.download_changelist(txn, remote, from, paths).await,
            RemoteRepo::LocalChannel(_) => Ok(HashSet::new()),

        inodes: &HashSet<Position<Hash>>,

    ) -> Result<(), anyhow::Error> {

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

        let mut to_apply_inodes = Vec::new();

            let touches_inodes = inodes.is_empty()
                || {
                    debug!("inodes = {:?}", inodes);
                    use libpijul::changestore::ChangeStore;
                    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
                            }
                        })
                    })
                }
                || { inodes.iter().any(|i| i.change == *h) };
            if touches_inodes {
                to_apply_inodes.push(*h);
            } else {
                continue;
            }

        Ok(())

        Ok(to_apply_inodes)

            self.pull(repo, txn, channel, &to_unrecord, false).await?;

            self.pull(repo, txn, channel, &to_unrecord, &HashSet::new(), false)
                .await?;

        self.pull(repo, txn, channel, &to_pull, true).await?;

        self.pull(repo, txn, channel, &to_pull, &HashSet::new(), true)
            .await?;

        let remote_changes = self

        let (inodes, remote_changes) = self

        self.pull(repo, txn, local_channel, &pullable, true).await

        self.pull(repo, txn, local_channel, &pullable, &inodes, true)
            .await?;
        Ok(())

fn parse_line(data: &str) -> Result<(u64, Hash, Merkle), anyhow::Error> {

use libpijul::pristine::{ChangePosition, Position};
use regex::Regex;
lazy_static! {
    static ref CHANGELIST_LINE: Regex =
        Regex::new(r#"(?P<num>[0-9]+)\.(?P<hash>[A-Za-z0-9]+)\.(?P<merkle>[A-Za-z0-9]+)"#).unwrap();
    static ref PATHS_LINE: Regex =
        Regex::new(r#"(?P<hash>[A-Za-z0-9]+)\.(?P<num>[0-9]+)"#).unwrap();
}
enum ListLine {
    Change { n: u64, h: Hash, m: Merkle },
    Position(Position<Hash>),
}
fn parse_line(data: &str) -> Result<ListLine, anyhow::Error> {

    let mut it = data.split('.');
    let n = if let Some(n) = it.next().and_then(|n| n.parse().ok()) {
        n
    } else {
        return Err((Error::ProtocolError {
            line: data.as_bytes().to_vec(),
        })
        .into());
    };
    debug!("n = {:?}", n);
    let h = if let Some(h) = it.next().and_then(|h| Hash::from_base32(h.as_bytes())) {
        h
    } else {
        return Err((Error::ProtocolError {
            line: data.as_bytes().to_vec(),
        })
        .into());
    };
    debug!("h = {:?}", h);
    let m = if let Some(m) = it.next().and_then(|m| {
        debug!("m =  {:?}", m);
        Merkle::from_base32(m.as_bytes())
    }) {
        m
    } else {
        return Err((Error::ProtocolError {
            line: data.as_bytes().to_vec(),
        })
        .into());
    };
    debug!("m = {:?}", m);
    if it.next().is_some() {
        return Err((Error::ProtocolError {
            line: data.as_bytes().to_vec(),
        })
        .into());

    if let Some(caps) = CHANGELIST_LINE.captures(data) {
        if let (Some(h), Some(m)) = (
            Hash::from_base32(caps.name("hash").unwrap().as_str().as_bytes()),
            Merkle::from_base32(caps.name("merkle").unwrap().as_str().as_bytes()),
        ) {
            return Ok(ListLine::Change {
                n: caps.name("num").unwrap().as_str().parse()?,
                h,
                m,
            });
        }
    }
    if let Some(caps) = PATHS_LINE.captures(data) {
        return Ok(ListLine::Position(Position {
            change: Hash::from_base32(caps.name("hash").unwrap().as_str().as_bytes()).unwrap(),
            pos: ChangePosition(caps.name("num").unwrap().as_str().parse().unwrap()),
        }));

    Ok((n, h, m))

    bail!("Protocol error, offending line: {:?}", data)

use std::collections::HashSet;

use libpijul::pristine::{Base32, Hash, Merkle, MutTxnT, TxnT};

use libpijul::pristine::{Base32, Hash, Merkle, MutTxnT, Position, TxnT};

    ) -> Result<(), anyhow::Error> {

    ) -> Result<HashSet<Position<Hash>>, anyhow::Error> {

            return Ok(());

            return Ok(HashSet::new());

        let mut paths_ = Vec::new();

        let mut paths_ = HashSet::new();
        let mut result = HashSet::new();

                paths_.push(p)

                debug!("p = {:?}", p);
                result.insert(Position {
                    change: remote_txn.get_external(p.change).unwrap(),
                    pos: p.pos,
                });
                paths_.insert(p);
                paths_.extend(libpijul::fs::iter_graph_descendants(
                    &remote_txn,
                    &remote_channel.borrow(),
                    p,
                ));

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

        Ok(())

        Ok(result)

use std::collections::HashSet;

use libpijul::pristine::Base32;

use libpijul::pristine::{Base32, MutTxnT, Position};
use libpijul::{Hash, RemoteRef};

    pub async fn download_changelist<T: MutTxnT>(
        &self,
        txn: &mut T,
        remote: &mut RemoteRef<T>,
        from: u64,
        paths: &[String],
    ) -> Result<HashSet<Position<Hash>>, anyhow::Error> {
        let url = self.url.clone() + "/" + super::DOT_DIR;
        let from_ = from.to_string();
        let mut query = vec![("changelist", &from_), ("channel", &self.channel)];
        for p in paths.iter() {
            query.push(("path", p));
        }
        let res = self.client.get(&url).query(&query).send().await?;
        if !res.status().is_success() {
            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());
        }
        let resp = res.bytes().await?;
        let mut result = HashSet::new();
        if let Ok(data) = std::str::from_utf8(&resp) {
            for l in data.lines() {
                if !l.is_empty() {
                    match super::parse_line(l)? {
                        super::ListLine::Change { n, m, h } => {
                            txn.put_remote(remote, n, (h, m))?;
                        }
                        super::ListLine::Position(pos) => {
                            result.insert(pos);
                        }
                    }
                } else {
                    break;
                }
            }
        }
        Ok(result)
    }

    #[error("Ambiguous path: {:?}", path)]
    AmbiguousPath { path: String },

    #[error("Changes not found: {:?}", hashes)]
    ChangesNotFound { hashes: Vec<String> },

            let now = std::time::Instant::now();

            txn.commit()?

            txn.commit()?;
            debug!("now = {:?}", now.elapsed());

        let locks = libpijul::TIMERS.lock().unwrap();
        debug!(
            "retrieve: {:?}, graph: {:?}, output: {:?}",
            locks.alive_retrieve, locks.alive_graph, locks.alive_output,
        );

use anyhow::bail;

    path: Option<String>,

    path: Vec<String>,

    path: Option<String>,

    path: Vec<String>,

            return Err(crate::Error::MissingRemote.into());

            bail!("Missing remote");

        let mut paths = if let Some(p) = self.path {
            vec![p]
        } else {
            vec![]
        };
        let remote_changes = remote.update_changelist(&mut txn, &paths).await?;

        let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;

        let path = if let Some(path) = paths.pop() {
            let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, &path)?;

        let mut paths = HashSet::new();
        for path in self.path.iter() {
            let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, path)?;

                return Err((crate::Error::AmbiguousPath { path }).into());

                bail!("Ambiguous path: {:?}", path)

            Some(p)
        } else {
            None
        };

            paths.insert(p);
            paths.extend(libpijul::fs::iter_graph_descendants(
                &txn,
                &channel.borrow(),
                p,
            ));
        }

            if let Some(ref remote_changes) = remote_changes {

            if let Some((_, ref remote_changes)) = remote_changes {

                    if let Some(ref p) = path {
                        if txn.get_touched_files(*p, Some(h_int)).is_some() {
                            to_upload.push(h)

                    if paths.is_empty() {
                        to_upload.push(h)
                    } else {
                        for p in paths.iter() {
                            if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                to_upload.push(h);
                                break;
                            }

                    } else {
                        to_upload.push(h)

                        if let Some(ref p) = path {
                            if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                to_upload.push(h)

                        if paths.is_empty() {
                            to_upload.push(h)
                        } else {
                            for p in paths.iter() {
                                if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                    to_upload.push(h);
                                    break;
                                }

                        } else {
                            to_upload.push(h)

                return Err((crate::Error::ChangesNotFound { hashes: not_found }).into());

                bail!("Changes not found: {:?}", not_found)

            let remote_changes = remote_changes.map(|x| x.1);

            return Err(crate::Error::MissingRemote.into());

            bail!("Missing remote")

        let to_download = if self.changes.is_empty() {
            let mut paths = if let Some(p) = self.path {
                vec![p]
            } else {
                vec![]
            };
            let remote_changes = remote.update_changelist(&mut txn, &paths).await?;

        let mut inodes: HashSet<libpijul::pristine::Position<libpijul::Hash>> = HashSet::new();
        let mut to_download = if self.changes.is_empty() {
            let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;

            if let Some(ref remote_changes) = remote_changes {

            if let Some((inodes_, remote_changes)) = remote_changes {
                inodes.extend(inodes_.into_iter());

                let path = if let Some(path) = paths.pop() {
                    let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, &path)?;

                let mut inodes_ = HashSet::new();
                for path in self.path.iter() {
                    let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, path)?;

                        return Err((crate::Error::AmbiguousPath { path }).into());

                        bail!("Ambiguous path: {:?}", path)

                    Some(p)
                } else {
                    None
                };

                    inodes_.insert(p);
                    inodes_.extend(libpijul::fs::iter_graph_descendants(
                        &txn,
                        &channel.borrow(),
                        p,
                    ));
                }
                inodes.extend(inodes_.iter().map(|x| libpijul::pristine::Position {
                    change: txn.get_external(x.change).unwrap(),
                    pos: x.pos,
                }));

                            if let Some(ref p) = path {
                                if txn.get_touched_files(*p, Some(h_int)).is_some() {
                                    to_download.push(h)
                                }
                            } else {

                            if inodes_.is_empty()
                                || inodes_.iter().any(|&inode| {
                                    txn.get_rev_touched_files(h_int, Some(inode)).is_some()
                                })
                            {

        debug!("recording");
        let hash = super::pending(&mut txn, &mut channel, &mut repo)?;
        let to_download = remote
            .pull(
                &mut repo,
                &mut txn,
                &mut channel,
                &mut to_download,
                &inodes,
                self.all,
            )
            .await?;

        debug!("recording");
        let hash = super::pending(&mut txn, &mut channel, &mut repo)?;
        remote
            .pull(&mut repo, &mut txn, &mut channel, &to_download, self.all)
            .await?;

        txn.output_repository_no_pending(
            &mut repo.working_copy,
            &repo.changes,
            &mut channel,
            "",
            true,
        )?;

        debug!("inodes = {:?}", inodes);
        if inodes.is_empty() {
            txn.output_repository_no_pending(
                &mut repo.working_copy,
                &repo.changes,
                &mut channel,
                "",
                true,
            )?;
        } else {
            for i in inodes {
                let i = if let Some(change) = txn.get_internal(i.change) {
                    libpijul::pristine::Position { change, pos: i.pos }
                } else {
                    continue;
                };
                let (path, _) =
                    libpijul::fs::find_path(&repo.changes, &txn, &channel.borrow(), false, i)?;
                debug!("path = {:?}", path);
                txn.output_repository_no_pending(
                    &mut repo.working_copy,
                    &repo.changes,
                    &mut channel,
                    &path,
                    true,
                )?;
            }
        }

                return Err((crate::Error::MissingDep { h: *n }).into());

                bail!("Missing dependency: {:?}", n)

use std::collections::HashMap;

use std::collections::{HashMap, HashSet};

    static ref CHANGELIST_PATHS: Regex = Regex::new(r#""((\\")|[^"])+""#).unwrap();

    static ref CHANGELIST_PATHS: Regex = Regex::new(r#""(((\\")|[^"])+)""#).unwrap();

                let mut paths = Vec::new();

                let mut paths = HashSet::new();
                debug!("cap[3] = {:?}", &cap[3]);

                    let s: String = r[0].parse().unwrap();

                    let s: String = r[1].replace("\\\"", "\"");

                        paths.push(p)

                        let h = txn.get_external(p.change).unwrap();
                        writeln!(o, "{}.{}", h.to_base32(), p.pos.0)?;
                        paths.insert(p);
                        paths.extend(libpijul::fs::iter_graph_descendants(
                            &txn,
                            &channel.borrow(),
                            p,
                        ));

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

                        || paths
                            .iter()
                            .any(|x| txn.get_touched_files(*x, Some(h_int)).is_some())

                        || paths.iter().any(|x| {
                            x.change == h_int || txn.get_touched_files(*x, Some(h_int)).is_some()
                        })

    debug!("registering change {:?}", hash);

        debug!(target:"libpijul::register_change", "dep = {:?}", dep);

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

        debug!(target:"libpijul::register_change", "{:?} depends on {:?}", internal, dep_internal);

        debug!("{:?} depends on {:?}", internal, dep_internal);

        let inode = match *hunk {
            Atom::NewVertex(NewVertex { ref inode, .. }) => inode,
            Atom::EdgeMap(EdgeMap { ref inode, .. }) => inode,

        let (inode, pos) = match *hunk {
            Atom::NewVertex(NewVertex {
                ref inode,
                ref flag,
                ref start,
                ref end,
                ..
            }) => {
                if flag.contains(EdgeFlags::FOLDER) && start == end {
                    (inode, Some(*start))
                } else {
                    (inode, None)
                }
            }
            Atom::EdgeMap(EdgeMap { ref inode, .. }) => (inode, None),

        debug!(target:"libpijul::register_change", "touched: {:?} {:?}", inode, internal);

        debug!("touched: {:?} {:?}", inode, internal);

        if let Some(pos) = pos {
            let inode = Position {
                change: internal,
                pos,
            };
            txn.put_touched_files(inode, internal)?;
            txn.put_rev_touched_files(internal, inode)?;
        }

use std::collections::HashSet;

}
/// An iterator over the descendants of an
/// inode key in the graph.
///
/// Constructed using
/// [`iter_graph_descendants`](fn.iter_graph_descendants.html).
pub struct GraphDescendants<'txn, 'channel, T: TxnT> {
    txn: &'txn T,
    channel: &'channel Channel<T>,
    stack: Vec<AdjacentIterator<'txn, T>>,
    visited: HashSet<Position<ChangeId>>,

impl<'txn, 'channel, T: TxnT> Iterator for GraphDescendants<'txn, 'channel, T> {
    type Item = Position<ChangeId>;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(mut adj) = self.stack.pop() {
            if let Some(child) = adj.next() {
                self.stack.push(adj);
                let dest = find_block(self.txn, &self.channel, child.dest).unwrap();
                let grandchild = iter_adjacent(
                    self.txn,
                    &self.channel,
                    dest,
                    EdgeFlags::FOLDER,
                    EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                )
                .next()
                .unwrap();
                if self.visited.insert(grandchild.dest) {
                    self.stack.push(iter_adjacent(
                        self.txn,
                        &self.channel,
                        grandchild.dest.inode_vertex(),
                        EdgeFlags::FOLDER,
                        EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                    ))
                }
                return Some(grandchild.dest);
            } else {
                // No child left, actually pop.
            }
        }
        None
    }
}
/// Returns a list of files under the given key.  The root key is
/// [`pristine::Vertex::ROOT`](../pristine/constant.Vertex::ROOT.html).
pub fn iter_graph_descendants<'txn, 'channel, T: TxnT>(
    txn: &'txn T,
    channel: &'channel Channel<T>,
    key: Position<ChangeId>,
) -> GraphDescendants<'txn, 'channel, T> {
    GraphDescendants {
        stack: vec![iter_adjacent(
            txn,
            &channel,
            key.inode_vertex(),
            EdgeFlags::FOLDER,
            EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
        )],
        visited: HashSet::new(),
        txn,
        channel,
    }
}

    }
    fn get_changes(
        &self,
        hash: &Hash,
    ) -> Result<Vec<crate::change::Record<Option<Hash>, crate::change::Local>>, Self::Error> {
        Ok(self.get_change(hash)?.hashed.changes)