//! Copyright (c) 2022-2026 GitDataAi All rights reserved.

mod common;

fn hdr() -> gitks::pb::RepositoryHeader {
    gitks::pb::RepositoryHeader {
        relative_path: "test-repo".into(),
        ..Default::default()
    }
}

#[tokio::test]
async fn test_list_refs_via_service() {
    let (dir, _gb) = common::setup_bare_repo();
    let svc = common::setup_service(dir.path());

    // list_refs is called internally by advertise_refs
    // We test it indirectly through the service
    use gitks::pb::pack_service_server::PackService;
    let result = svc
        .advertise_refs(tonic::Request::new(gitks::pb::AdvertiseRefsRequest {
            repository: Some(hdr()),
            protocol: None,
            service: String::new(),
            raw: false,
        }))
        .await
        .unwrap()
        .into_inner();

    assert!(!result.references.is_empty(), "should have refs");
    let names: Vec<&str> = result.references.iter().map(|r| r.name.as_str()).collect();
    assert!(
        names.iter().any(|n| n.contains("refs/heads/main")),
        "should have main branch, got: {:?}",
        names
    );
    assert!(
        names.iter().any(|n| n.contains("refs/heads/feature")),
        "should have feature branch, got: {:?}",
        names
    );
    assert!(
        names.iter().any(|n| n.contains("refs/tags/v0.1.0")),
        "should have tag, got: {:?}",
        names
    );
}

#[test]
fn test_list_refs_direct() {
    let (_dir, gb) = common::setup_bare_repo();
    let refs = gb.list_refs().expect("list_refs");

    assert!(!refs.is_empty());
    let names: Vec<&str> = refs.iter().map(|r| r.name.as_str()).collect();
    assert!(names.iter().any(|n| n.contains("refs/heads/main")));
    assert!(names.iter().any(|n| n.contains("refs/heads/feature")));
    assert!(names.iter().any(|n| n.contains("refs/tags/v0.1.0")));

    // Each ref should have a valid target OID
    for r in &refs {
        let oid = r.target_oid.as_ref().expect("ref should have target_oid");
        assert!(!oid.hex.is_empty(), "OID hex should not be empty");
        assert_eq!(oid.hex.len(), 40, "SHA-1 hex should be 40 chars");
    }
}

#[test]
fn test_write_ref_and_ref_exists() {
    let (_dir, gb) = common::setup_bare_repo();
    let oid = common::get_main_oid(&gb);
    let resp = gb
        .write_ref(gitks::pb::WriteRefRequest {
            repository: Some(hdr()),
            ref_name: "refs/heads/test-write".into(),
            new_oid: oid,
            old_oid: String::new(),
            force: false,
        })
        .unwrap();
    assert!(resp.ok, "write_ref failed: {}", resp.error);

    let exists = gb
        .ref_exists(gitks::pb::RefExistsRequest {
            repository: Some(hdr()),
            ref_name: "refs/heads/test-write".into(),
        })
        .unwrap();
    assert!(exists.exists);

    let not_exists = gb
        .ref_exists(gitks::pb::RefExistsRequest {
            repository: Some(hdr()),
            ref_name: "refs/heads/nonexistent".into(),
        })
        .unwrap();
    assert!(!not_exists.exists);
}

#[test]
fn test_update_references_batch() {
    let (_dir, gb) = common::setup_bare_repo();
    let oid = common::get_main_oid(&gb);
    let resp = gb
        .update_references(gitks::pb::UpdateReferencesRequest {
            repository: Some(hdr()),
            updates: vec![
                gitks::pb::RefUpdateEntry {
                    ref_name: "refs/heads/batch-a".into(),
                    new_oid: oid.clone(),
                    old_oid: String::new(),
                },
                gitks::pb::RefUpdateEntry {
                    ref_name: "refs/heads/batch-b".into(),
                    new_oid: oid,
                    old_oid: String::new(),
                },
            ],
        })
        .unwrap();
    assert!(resp.failed_refs.is_empty(), "error: {}", resp.error);

    let a = gb
        .ref_exists(gitks::pb::RefExistsRequest {
            repository: Some(hdr()),
            ref_name: "refs/heads/batch-a".into(),
        })
        .unwrap();
    assert!(a.exists);
}

#[test]
fn test_update_references_empty() {
    let (_dir, gb) = common::setup_bare_repo();
    let resp = gb
        .update_references(gitks::pb::UpdateReferencesRequest {
            repository: Some(hdr()),
            updates: vec![],
        })
        .unwrap();
    assert!(resp.failed_refs.is_empty());
}

#[test]
fn test_delete_refs() {
    let (_dir, gb) = common::setup_bare_repo();
    let oid = common::get_main_oid(&gb);
    gb.write_ref(gitks::pb::WriteRefRequest {
        repository: Some(hdr()),
        ref_name: "refs/heads/to-delete".into(),
        new_oid: oid,
        old_oid: String::new(),
        force: false,
    })
    .unwrap();

    let resp = gb
        .delete_refs(gitks::pb::DeleteRefsRequest {
            repository: Some(hdr()),
            ref_names: vec!["refs/heads/to-delete".into()],
        })
        .unwrap();
    assert!(resp.failed_refs.is_empty());

    let exists = gb
        .ref_exists(gitks::pb::RefExistsRequest {
            repository: Some(hdr()),
            ref_name: "refs/heads/to-delete".into(),
        })
        .unwrap();
    assert!(!exists.exists);
}

#[test]
fn test_find_default_branch_name() {
    let (_dir, gb) = common::setup_bare_repo();
    let resp = gb.find_default_branch_name().unwrap();
    assert_eq!(resp.name, "main");
}