use crate::utils::hg_path::HgPath;

use itertools::put_back;

use itertools::PutBack;

use std::cmp::Ordering;

// Find an item in an iterator over a sorted collection.

fn find_item<'a, 'b, 'c, D, I: Iterator<Item = (&'a HgPath, D)>>(

    i: &mut PutBack<I>,

    needle: &'b HgPath,

) -> Option<I::Item> {

    loop {

        match i.next() {

            None => return None,

            Some(val) => match needle.as_bytes().cmp(val.0.as_bytes()) {

                Ordering::Less => {

                    i.put_back(val);

                    return None;

                }

                Ordering::Greater => continue,

                Ordering::Equal => return Some(val),

            },

        }

    }

}

fn find_files_in_manifest<

    'a,

    'b,

    D,

    I: Iterator<Item = (&'a HgPath, D)>,

    J: Iterator<Item = &'b HgPath>,

>(

    manifest: I,

    files: J,

) -> (Vec<(&'a HgPath, D)>, Vec<&'b HgPath>) {

    let mut manifest = put_back(manifest);

    let mut res = vec![];

    let mut missing = vec![];

    for file in files {

        match find_item(&mut manifest, file) {

            None => missing.push(file),

            Some(item) => res.push(item),

        }

    }

    return (res, missing);

}

    let mut bytes: Vec<u8> = vec![];

    let (found, missing) = find_files_in_manifest(

        manifest.files_with_nodes(),

        files.iter().map(|f| f.as_ref()),

    );

    for (manifest_file, node_bytes) in found {

        found_any = true;

        let file_log = repo.filelog(manifest_file)?;

        let file_node = Node::from_hex_for_repo(node_bytes)?;

        bytes.extend(file_log.data_for_node(file_node)?.data()?);

        .map(|file| (*file).to_owned())