use std::path::PathBuf;

use git_pack::multi_index::File;
use git_testtools::hex_to_id;

fn multi_index() -> (File, PathBuf) {
    let path = git_testtools::scripted_fixture_repo_read_only("make_pack_gen_repo_multi_index.sh")
        .expect("test fixture exists")
        .join(".git/objects/pack/multi-pack-index");
    let file = git_pack::multi_index::File::at(&path).unwrap();
    (file, path)
}

#[test]
fn access() {
    let (file, path) = multi_index();

    assert_eq!(file.version(), git_pack::multi_index::Version::V1);
    assert_eq!(file.path(), path);
    assert_eq!(file.num_indices(), 1);
    assert_eq!(file.object_hash(), git_hash::Kind::Sha1);
    assert_eq!(file.num_objects(), 868);
    assert_eq!(file.checksum(), hex_to_id("39a3804d0a84de609e4fcb49e66dc1297c75ca11"));
    // assert_eq!()
    assert_eq!(
        file.index_names(),
        vec![PathBuf::from("pack-542ad1d1c7c762ea4e36907570ff9e4b5b7dde1b.idx")]
    );

    for (idx, expected_pack_offset, expected_oid) in &[
        (0u32, 25267u64, hex_to_id("000f574443efab4ddbeee3621e49124eb3f8b6d0")),
        (140, 30421, hex_to_id("2935a65b1d69fb33c93dabc4cdf65a6f4d30ce4c")),
        (867, 24540, hex_to_id("ffea360a6a54c1185eeae4f3cfefc927cf7a35a9")),
    ] {
        let actual_oid = file.oid_at_index(*idx);
        assert_eq!(actual_oid, *expected_oid);
        assert_eq!(file.lookup(actual_oid), Some(*idx));
        let (pack_id, pack_offset) = file.pack_id_and_pack_offset_at_index(*idx);
        assert_eq!(pack_id, 0, "we only have one pack here");
        assert_eq!(pack_offset, *expected_pack_offset);
    }

    let mut count = 0;
    for (idx, entry) in file.iter().enumerate() {
        assert_eq!(entry.oid, file.oid_at_index(idx as u32));
        let (pack_index, pack_offset) = file.pack_id_and_pack_offset_at_index(idx as u32);
        assert_eq!(pack_index, entry.pack_index);
        assert_eq!(pack_offset, entry.pack_offset);
        count += 1;
    }
    assert_eq!(count, file.num_objects());
}

mod verify {
    use std::sync::atomic::AtomicBool;

    use common_macros::b_tree_map;
    use git_features::progress;

    use crate::pack::multi_index::multi_index;

    #[test]
    fn checksum() -> crate::Result {
        let (file, _) = multi_index();
        assert_eq!(
            file.verify_checksum(progress::Discard, &AtomicBool::new(false))?,
            file.checksum()
        );
        Ok(())
    }

    #[test]
    fn integrity() {
        let (file, _) = multi_index();
        let outcome = file
            .verify_integrity(progress::Discard, &AtomicBool::new(false), Default::default())
            .unwrap();
        assert_eq!(outcome.actual_index_checksum, file.checksum());
        assert_eq!(
            outcome.pack_traverse_statistics,
            vec![git_pack::index::traverse::Statistics {
                average: git_pack::data::decode_entry::Outcome {
                    kind: git_object::Kind::Tree,
                    num_deltas: 1,
                    decompressed_size: 47,
                    compressed_size: 46,
                    object_size: 152
                },
                objects_per_chain_length: b_tree_map! {
                    0 => 326,
                    1 => 106,
                    2 => 326,
                    3 => 108,
                    4 => 2,
                },
                total_compressed_entries_size: 40628,
                total_decompressed_entries_size: 40919,
                total_object_size: 131993,
                pack_size: 42856,
                num_commits: 16,
                num_trees: 40,
                num_tags: 1,
                num_blobs: 811
            }]
        );
    }
}

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

    use git_features::progress;
    use git_testtools::{fixture_path, hex_to_id};

    #[test]
    fn from_paths() -> crate::Result {
        let dir = tempfile::TempDir::new()?;
        let input_indices = std::fs::read_dir(fixture_path("objects/pack"))?
            .filter_map(|r| {
                r.ok()
                    .map(|e| e.path())
                    .filter(|p| p.extension().and_then(|e| e.to_str()).unwrap_or("") == "idx")
            })
            .collect::<Vec<_>>();
        assert_eq!(input_indices.len(), 3);
        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 = git_pack::multi_index::File::write_from_index_paths(
            input_indices.clone(),
            &mut out,
            progress::Discard,
            &AtomicBool::new(false),
            git_pack::multi_index::write::Options {
                object_hash: git_hash::Kind::Sha1,
            },
        )?;

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

        let file = git_pack::multi_index::File::at(output_path)?;
        assert_eq!(file.num_indices(), 3);
        assert_eq!(
            file.index_names(),
            vec![
                PathBuf::from("pack-11fdfa9e156ab73caae3b6da867192221f2089c2.idx"),
                PathBuf::from("pack-a2bf8e71d8c18879e499335762dd95119d93d9f1.idx"),
                PathBuf::from("pack-c0438c19fb16422b6bbcce24387b3264416d485b.idx"),
            ]
        );
        assert_eq!(file.num_objects(), 139);
        assert_eq!(file.checksum(), outcome.multi_index_checksum);

        for index in &input_indices {
            std::fs::copy(index, dir.path().join(index.file_name().expect("present")))?;
            let pack = index.with_extension("pack");
            std::fs::copy(&pack, dir.path().join(pack.file_name().expect("present")))?;
        }

        assert_eq!(
            file.verify_integrity(progress::Discard, &AtomicBool::new(false), Default::default())?
                .actual_index_checksum,
            outcome.multi_index_checksum
        );

        let outcome = file.verify_integrity_fast(progress::Discard, &AtomicBool::new(false))?;

        assert_eq!(outcome.0, file.checksum());
        Ok(())
    }
}