mod common;

use gitks::pb::*;

#[test]
fn test_list_tags() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .list_tags(ListTagsRequest {
            repository: None,
            pattern: String::new(),
            pagination: None,
            sort_direction: 0,
        })
        .expect("list_tags");
    let names: Vec<String> = result.tags.iter().map(|t| t.name.clone()).collect();
    assert!(names.contains(&"v0.1.0".to_string()));
}

#[test]
fn test_get_tag() {
    let (_dir, gb) = common::setup_bare_repo();
    let tag = gb
        .get_tag(GetTagRequest {
            repository: None,
            name: "v0.1.0".into(),
            include_raw: false,
        })
        .expect("get_tag");

    assert_eq!(tag.name, "v0.1.0");
    assert!(tag.target_oid.is_some());
    assert_eq!(tag.full_ref, "refs/tags/v0.1.0");
}

#[test]
fn test_create_and_delete_lightweight_tag() {
    let (_dir, gb) = common::setup_bare_repo();
    let tag = gb
        .create_tag(CreateTagRequest {
            repository: None,
            name: "v0.2.0".into(),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            message: String::new(),
            tagger: None,
            force: false,
            annotated: false,
        })
        .expect("create_tag");

    assert_eq!(tag.name, "v0.2.0");
    assert!(!tag.annotated);

    gb.delete_tag(DeleteTagRequest {
        repository: None,
        name: "v0.2.0".into(),
    })
    .expect("delete_tag");

    let result = gb.get_tag(GetTagRequest {
        repository: None,
        name: "v0.2.0".into(),
        include_raw: false,
    });
    assert!(result.is_err(), "deleted tag should not exist");
}

#[test]
fn test_create_annotated_tag() {
    let (_dir, gb) = common::setup_bare_repo();
    let tag = gb
        .create_tag(CreateTagRequest {
            repository: None,
            name: "v1.0.0".into(),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            message: "Release v1.0.0".into(),
            tagger: None,
            force: false,
            annotated: true,
        })
        .expect("create annotated tag");

    assert_eq!(tag.name, "v1.0.0");
    assert!(tag.annotated, "should be annotated");
    assert!(tag.tag_oid.is_some(), "annotated tag should have tag_oid");
    assert!(
        tag.message.contains("Release v1.0.0"),
        "message should be set"
    );
}

#[test]
fn test_list_tags_with_pattern() {
    let (_dir, gb) = common::setup_bare_repo();

    gb.create_tag(CreateTagRequest {
        repository: None,
        name: "release-1.0".into(),
        target: Some(ObjectSelector {
            selector: Some(object_selector::Selector::Revision(ObjectName {
                revision: "main".into(),
            })),
        }),
        message: String::new(),
        tagger: None,
        force: false,
        annotated: false,
    })
    .expect("create release tag");

    let result = gb
        .list_tags(ListTagsRequest {
            repository: None,
            pattern: "release".into(),
            pagination: None,
            sort_direction: 0,
        })
        .expect("list_tags with pattern");

    assert!(
        result.tags.iter().all(|t| t.name.contains("release")),
        "all tags should match pattern"
    );
    assert!(!result.tags.is_empty());
}

#[test]
fn test_verify_tag() {
    let (_dir, gb) = common::setup_bare_repo();
    let result = gb
        .verify_tag(VerifyTagRequest {
            repository: None,
            name: "v0.1.0".into(),
        })
        .expect("verify_tag");

    assert!(!result.verified, "unsigned tag should not be verified");
}