use libpijul::change::PrintableHunk;

use libpijul::change::{Atom, Author, Change, Hunk, PrintableHunk};

use libpijul::{ChangeId, GraphTxnT, Hash, TxnTExt};

use libpijul::{ChangeId, ChannelTxnT, GraphTxnT, Hash, MutTxnTExt, TxnTExt};

    changes: Vec<(ChangeId, usize)>,

    hashes: Vec<(ChangeId, u64)>,

        Ok(Self {
            changes: Vec::new(),
        })

        Ok(Self { hashes: Vec::new() })

            if let Some((last_change, lines)) = self.changes.last_mut() {

            if let Some((last_change, lines)) = self.hashes.last_mut() {

            self.changes.push((key.change, 1));

            self.hashes.push((key.change, 1));

pub fn file_credits(path: PathBuf) -> Result<Vec<(Hash, usize)>, anyhow::Error> {

pub fn file_credits(path: PathBuf) -> Result<(Vec<Change>, Vec<(Hash, u64)>), anyhow::Error> {

    let write_txn = txn.write();

    let mut record_builder = RecordBuilder::new();
    record_builder.record(
        txn.clone(),
        libpijul::Algorithm::default(),
        false,
        &libpijul::DEFAULT_SEPARATOR,
        channel.clone(),
        &repo.working_copy,
        &repo.changes,
        &prefix,
        std::thread::available_parallelism()?.into(),
    )?;
    let recorded = record_builder.finish();
    let mut write_txn = txn.write();
    let actions: Vec<_> = recorded
        .actions
        .into_iter()
        .map(|rec| rec.globalize(&*write_txn).unwrap())
        .collect();
    let contents = if let Ok(cont) = std::sync::Arc::try_unwrap(recorded.contents) {
        cont.into_inner()
    } else {
        unreachable!()
    };
    let mut change = LocalChange::make_change(
        &*write_txn,
        &channel,
        actions,
        contents,
        ChangeHeader::default(),
        Vec::new(),
    )?;

    repo.changes
        .save_change(&mut change, |_, _| Ok::<_, anyhow::Error>(()))?;
    write_txn.apply_change(&repo.changes, &mut channel.write(), &change.hash()?)?;

    for (change_id, lines) in credit_buffer.changes {
        let hash = txn.read().get_external(&change_id)?.unwrap().to_owned();
        hashes.push((Hash::from(hash), lines));

    let mut changes: Vec<Change> = Vec::new();
    for (change_id, lines) in credit_buffer.hashes {
        let hash = Hash::from(txn.read().get_external(&change_id)?.unwrap().to_owned());
        let change = repo.changes.get_change(&hash)?;
        if !changes.iter().any(|c| c.hash().unwrap() == hash) {
            changes.push(change);
        }
        hashes.push((hash, lines));

    Ok(hashes)

    // Make sure to not pollute .pijul/changes
    repo.changes.del_change(&change.hash()?)?;
    Ok((changes, hashes))

fn inline_credit(mut cx: FunctionContext) -> JsResult<JsString> {
    let path: Handle<JsString> = cx.argument(0)?;
    let path = PathBuf::from(path.value(&mut cx));
    let target_line: Handle<JsNumber> = cx.argument(1)?;
    let target_line: f64 = target_line.value(&mut cx);
    assert!(target_line.is_finite());
    assert_eq!(target_line.round(), target_line);
    let target_line: u64 = target_line as u64;

    let (changes, hashes) = file_credits(path).unwrap();
    let mut current_line: u64 = 0;
    for (hash, line_count) in hashes {
        if (current_line..current_line + line_count).contains(&target_line) {
            return Ok(cx.string(format!("{hash:?}")));
        }
        current_line += line_count;
    }
    Ok(cx.string("Inline diff error"))
}

    cx.export_function("inlineCredit", inline_credit)?;