use std::{
    path::{Path, PathBuf},
    sync::atomic::AtomicBool,
};

use gix_features::progress;
use gix_testtools::fixture_path;

use crate::hex_to_id;

/// Writes a multi-index from the static SHA-1 pack indices, with pinned SHA-1 expectations.
/// The SHA-256 counterpart lives in [`from_a_hash_parameterized_pack`] below.
#[test]
fn from_paths() -> crate::Result {
    let pack_dir = fixture_path("objects/pack");
    let written = write_multi_index_from_pack_dir(&pack_dir, gix_hash::Kind::Sha1)?;
    assert_eq!(written.input_indices.len(), 3);

    assert_eq!(
        written.outcome.multi_index_checksum,
        hex_to_id("d34d327039a3554f8a644b29e07b903fa71ef269")
    );

    assert_eq!(written.file.num_indices(), 3);
    assert_eq!(
        written.file.index_names(),
        vec![
            PathBuf::from("pack-11fdfa9e156ab73caae3b6da867192221f2089c2.idx"),
            PathBuf::from("pack-a2bf8e71d8c18879e499335762dd95119d93d9f1.idx"),
            PathBuf::from("pack-c0438c19fb16422b6bbcce24387b3264416d485b.idx"),
        ]
    );
    assert_eq!(written.file.num_objects(), 139);
    assert_eq!(written.file.checksum(), written.outcome.multi_index_checksum);

    written.verify_integrity_with_referenced_packs()?;
    Ok(())
}

/// Like [`from_paths`], but sources its input index from the hash-parameterized fixture so the
/// writer runs under both SHA-1 and SHA-256. The fixture's gc leaves one pack, hence one index.
#[test]
fn from_a_hash_parameterized_pack() -> crate::Result {
    let object_hash = crate::object_hash();
    let pack_dir = crate::scripted_fixture_read_only("make_pack_gen_repo_multi_index.sh")?.join(".git/objects/pack");
    let written = write_multi_index_from_pack_dir(&pack_dir, object_hash)?;
    assert_eq!(written.input_indices.len(), 1, "the aggressive gc leaves a single pack");

    assert_eq!(
        written.file.object_hash(),
        object_hash,
        "the writer records the requested object hash"
    );
    assert_eq!(written.file.num_indices(), 1);
    assert_eq!(written.file.num_objects(), 868);
    assert_eq!(written.file.checksum(), written.outcome.multi_index_checksum);

    written.verify_integrity_with_referenced_packs()?;
    Ok(())
}

struct WrittenMultiIndex {
    file: gix_pack::multi_index::File,
    dir: gix_testtools::tempfile::TempDir,
    input_indices: Vec<PathBuf>,
    outcome: gix_pack::multi_index::write::Outcome,
}

impl WrittenMultiIndex {
    fn verify_integrity_with_referenced_packs(&self) -> crate::Result {
        // Place the referenced pack and index next to the multi-index so integrity can resolve them.
        for ro_index in &self.input_indices {
            std::fs::copy(
                ro_index,
                self.dir
                    .path()
                    .join(ro_index.file_name().expect("index paths have file names")),
            )?;
            let ro_pack = ro_index.with_extension("pack");
            std::fs::copy(
                &ro_pack,
                self.dir
                    .path()
                    .join(ro_pack.file_name().expect("pack paths have file names")),
            )?;
        }

        assert_eq!(
            self.file
                .verify_integrity(&mut progress::Discard, &AtomicBool::new(false), Default::default())?
                .actual_index_checksum,
            self.outcome.multi_index_checksum,
            "full integrity verification returns the written multi-index checksum"
        );
        assert_eq!(
            self.file
                .verify_integrity_fast(&mut progress::Discard, &AtomicBool::new(false))?,
            self.file.checksum(),
            "fast integrity verification returns the checksum read from the file"
        );
        Ok(())
    }
}

fn write_multi_index_from_pack_dir(pack_dir: &Path, object_hash: gix_hash::Kind) -> crate::Result<WrittenMultiIndex> {
    let input_indices = std::fs::read_dir(pack_dir)?
        .filter_map(|r| {
            let idx_path = r.ok()?.path();
            (idx_path.extension()? == "idx").then_some(idx_path)
        })
        .collect::<Vec<_>>();

    let dir = gix_testtools::tempfile::TempDir::new()?;
    let output_path = dir.path().join("multi-pack-index");
    let mut out = std::fs::OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(&output_path)?;
    let outcome = gix_pack::multi_index::write_from_index_paths(
        input_indices.clone(),
        &mut out,
        &mut progress::Discard,
        &AtomicBool::new(false),
        gix_pack::multi_index::write::Options { object_hash },
    )?;
    let file = gix_pack::multi_index::File::at(output_path, None)?;

    Ok(WrittenMultiIndex {
        file,
        dir,
        input_indices,
        outcome,
    })
}