use filetime::FileTime;
use git_index::{entry, extension, verify::extensions::no_find, write, write::Options, State, Version};

use crate::{fixture_index_path, index::Fixture::*, loose_file_path};

/// Round-trips should eventually be possible for all files we have, as we write them back exactly as they were read.
#[test]
fn roundtrips() -> crate::Result {
    let input = [
        (Loose("extended-flags"), only_tree_ext()),
        (Loose("conflicting-file"), only_tree_ext()),
        (Loose("very-long-path"), only_tree_ext()),
        (
            Generated("v2"),
            options_with(write::Extensions::Given {
                tree_cache: true,
                end_of_index_entry: true,
            }),
        ),
        (Generated("V2_empty"), only_tree_ext()),
        (Generated("v2_more_files"), only_tree_ext()),
        (Generated("v2_all_file_kinds"), only_tree_ext()),
    ];

    for (fixture, options) in input {
        let (path, fixture) = match fixture {
            Generated(name) => (fixture_index_path(name), name),
            Loose(name) => (loose_file_path(name), name),
        };
        let expected = git_index::File::at(&path, git_hash::Kind::Sha1, Default::default())?;
        let expected_bytes = std::fs::read(&path)?;
        let mut out_bytes = Vec::new();

        let (actual_version, _digest) = expected.write_to(&mut out_bytes, options)?;
        let (actual, _) = State::from_bytes(&out_bytes, FileTime::now(), git_hash::Kind::Sha1, Default::default())?;

        compare_states_against_baseline(&actual, actual_version, &expected, options, fixture);
        compare_raw_bytes(&out_bytes, &expected_bytes, fixture);
    }
    Ok(())
}

#[test]
fn roundtrips_sparse_index() -> crate::Result {
    // NOTE: I initially tried putting these fixtures into the main roundtrip test above,
    // but the call to `compare_raw_bytes` panics. It seems like git is using a different
    // ordering when it comes to writing the tree extension. Need to investigate more, hence
    // the separate test for now.
    //
    //          git                     gitoxide
    //
    //          treeroot                treeroot
    //            | d                     | c1
    //            | d/c4                  | c1/c2
    //            | c1                    | c1/c3
    //            | c1/c2                 | d
    //            | c1/c3                 | d/c4
    //

    let input = [
        ("v3_skip_worktree", only_tree_ext()),
        ("v3_sparse_index_non_cone", only_tree_ext()),
        ("v3_sparse_index", only_tree_ext()),
        ("v2_sparse_index_no_dirs", only_tree_ext()),
    ];

    for (fixture, options) in input {
        let path = fixture_index_path(fixture);
        let expected = git_index::File::at(&path, git_hash::Kind::Sha1, Default::default())?;
        let _expected_bytes = std::fs::read(&path)?;
        let mut out_bytes = Vec::new();

        let (actual_version, _) = expected.write_to(&mut out_bytes, options)?;
        let (actual, _) = State::from_bytes(&out_bytes, FileTime::now(), git_hash::Kind::Sha1, Default::default())?;

        compare_states_against_baseline(&actual, actual_version, &expected, options, fixture);
        // TODO: make this work and re-enable it, once this is done the fixtures can be merged into the main "roundtrip" test
        // compare_raw_bytes(&out_bytes, &_expected_bytes, fixture);
    }
    Ok(())
}

#[test]
fn state_comparisons_with_various_extension_configurations() {
    for fixture in [
        Loose("extended-flags"),
        Loose("conflicting-file"),
        Loose("very-long-path"),
        Loose("FSMN"),
        Loose("REUC"),
        Loose("UNTR-with-oids"),
        Loose("UNTR"),
        Generated("V2_empty"),
        Generated("v2"),
        Generated("v2_more_files"),
        Generated("v2_all_file_kinds"),
        Generated("v2_split_index"),
        // TODO: this failes because git allows to configure the index version while gitoxide doesn't
        //       the fixture artificially sets the version to V4 and gitoxide writes it back out as the lowest required verison, V2
        // Generated("v4_more_files_IEOT"),
        Generated("v3_skip_worktree"),
        Generated("v3_sparse_index_non_cone"),
        Generated("v3_sparse_index"),
        // TODO: this fails because git writes the sdir extension in this case while gitoxide doesn't
        // Generated("v2_sparse_index_no_dirs"),
    ] {
        for options in [
            options_with(write::Extensions::None),
            options_with(write::Extensions::All),
            options_with(write::Extensions::Given {
                tree_cache: true,
                end_of_index_entry: false,
            }),
            options_with(write::Extensions::Given {
                tree_cache: false,
                end_of_index_entry: true,
            }),
        ] {
            let path = fixture.to_path();
            let fixture = fixture.to_name();
            let expected = git_index::File::at(&path, git_hash::Kind::Sha1, Default::default()).unwrap();

            let mut out = Vec::<u8>::new();
            let (actual_version, _digest) = expected.write_to(&mut out, options).unwrap();

            let (actual, _) =
                State::from_bytes(&out, FileTime::now(), git_hash::Kind::Sha1, Default::default()).unwrap();
            compare_states(&actual, actual_version, &expected, options, fixture);
        }
    }
}

#[test]
fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> crate::Result {
    let mut expected = git_index::File::at(fixture_index_path("v2"), git_hash::Kind::Sha1, Default::default())?;
    assert_eq!(expected.version(), Version::V2);
    expected.entries_mut()[0].flags.insert(entry::Flags::EXTENDED);

    let mut buf = Vec::new();
    let (actual_version, _digest) = expected.write_to(&mut buf, Default::default())?;
    assert_eq!(actual_version, Version::V3, "extended flags need V3");

    Ok(())
}

fn compare_states_against_baseline(
    actual: &State,
    actual_version: Version,
    expected: &State,
    options: Options,
    fixture: &str,
) {
    compare_states(actual, actual_version, expected, options, fixture);

    assert_eq!(
        actual.tree(),
        expected.tree(),
        "tree extension mismatch, actual vs expected in {:?}",
        fixture
    );
}

fn compare_states(actual: &State, actual_version: Version, expected: &State, options: Options, fixture: &str) {
    actual.verify_entries().expect("valid");
    actual.verify_extensions(false, no_find).expect("valid");

    assert_eq!(
        actual.version(),
        actual_version,
        "version mismatch, read vs written, in {:?}",
        fixture
    );
    assert_eq!(
        actual.tree(),
        options
            .extensions
            .should_write(extension::tree::SIGNATURE)
            .and_then(|_| expected.tree()),
        "tree extension mismatch, actual vs option in {:?}",
        fixture
    );

    // As `write_to` does / should not mutate we can test those properties here.
    // Anything that can be configured has to be tested separately when comparing againt baseline
    assert_eq!(
        actual.version(),
        expected.version(),
        "version mismatch, actual vs expected, in {:?}",
        fixture
    );
    assert_eq!(
        actual.is_sparse(),
        expected.is_sparse(),
        "sparse index entries extension mismatch in {:?}",
        fixture
    );
    assert_eq!(
        actual.entries().len(),
        expected.entries().len(),
        "entry count mismatch in {:?}",
        fixture
    );
    assert_eq!(
        actual.entries(),
        expected.entries(),
        "entries mismatch in {:?}",
        fixture
    );
    assert_eq!(
        actual.path_backing(),
        expected.path_backing(),
        "path_backing mismatch in {:?}",
        fixture
    );
}

fn compare_raw_bytes(generated: &[u8], expected: &[u8], fixture: &str) {
    assert_eq!(generated.len(), expected.len(), "file length mismatch in {:?}", fixture);

    let print_range = 10;
    for (index, (a, b)) in generated.iter().zip(expected.iter()).enumerate() {
        if a != b {
            let range_left = index.saturating_sub(print_range);
            let range_right = (index + print_range).min(generated.len());
            let generated = &generated[range_left..range_right];
            let expected = &expected[range_left..range_right];

            panic! {"\n\nRoundtrip failed for index in fixture {:?} at position {:?}\n\
            \t  Actual: ... {:?} ...\n\
            \tExpected: ... {:?} ...\n\n\
            ", &fixture, index, generated, expected}
        }
    }
}

fn only_tree_ext() -> Options {
    Options {
        extensions: write::Extensions::Given {
            end_of_index_entry: false,
            tree_cache: true,
        },
    }
}

fn options_with(extensions: write::Extensions) -> Options {
    Options { extensions }
}