mod common;

use gitks::pb::commit_service_server::CommitService;
use gitks::pb::merge_service_server::MergeService;
use gitks::pb::tree_service_server::TreeService;
use gitks::pb::*;

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

#[tokio::test]
async fn test_check_merge_no_conflict() {
    let (dir, _gb) = common::setup_bare_repo();
    let svc = common::setup_service(dir.path());
    let result = svc
        .check_merge(tonic::Request::new(CheckMergeRequest {
            repository: Some(hdr()),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "feature".into(),
                })),
            }),
            options: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert!(
        result.status == merge_result::Status::MergeResultStatusMerged as i32
            || result.status == merge_result::Status::MergeResultStatusFastForward as i32
            || result.status == merge_result::Status::MergeResultStatusAlreadyUpToDate as i32,
        "merge should be clean, got status: {}",
        result.status
    );
}

#[tokio::test]
async fn test_check_merge_with_conflict() {
    let (dir, _gb) = common::setup_bare_repo_with_conflict();
    let svc = common::setup_service(dir.path());
    let result = svc
        .check_merge(tonic::Request::new(CheckMergeRequest {
            repository: Some(hdr()),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-a".into(),
                })),
            }),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-b".into(),
                })),
            }),
            options: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        merge_result::Status::MergeResultStatusConflicts as i32,
        "merge should have conflicts"
    );
    assert!(!result.conflicts.is_empty(), "should list conflicted files");
}

#[tokio::test]
async fn test_check_merge_already_up_to_date() {
    let (dir, _gb) = common::setup_bare_repo();
    let svc = common::setup_service(dir.path());
    let result = svc
        .check_merge(tonic::Request::new(CheckMergeRequest {
            repository: Some(hdr()),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            options: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        merge_result::Status::MergeResultStatusAlreadyUpToDate as i32
    );
}

#[tokio::test]
async fn test_merge_fast_forward() {
    let (dir, _gb) = common::setup_bare_repo();
    let svc = common::setup_service(dir.path());
    let result = svc
        .merge(tonic::Request::new(MergeRequest {
            repository: Some(hdr()),
            target_branch: "feature".into(),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            committer: None,
            message: String::new(),
            options: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert!(
        result.status == merge_result::Status::MergeResultStatusFastForward as i32
            || result.status == merge_result::Status::MergeResultStatusAlreadyUpToDate as i32,
        "feature should fast-forward to main, got: {}",
        result.status
    );
}

#[tokio::test]
async fn test_merge_with_conflict() {
    let (dir, _gb) = common::setup_bare_repo_with_conflict();
    let svc = common::setup_service(dir.path());
    let result = svc
        .merge(tonic::Request::new(MergeRequest {
            repository: Some(hdr()),
            target_branch: "branch-a".into(),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-b".into(),
                })),
            }),
            committer: None,
            message: String::new(),
            options: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        merge_result::Status::MergeResultStatusConflicts as i32,
        "should detect conflicts"
    );
}

#[tokio::test]
async fn test_merge_fast_forward_only_aborts_non_fast_forward() {
    let (dir, _gb) = common::setup_bare_repo_with_conflict();
    let svc = common::setup_service(dir.path());
    let result = svc
        .merge(tonic::Request::new(MergeRequest {
            repository: Some(hdr()),
            target_branch: "branch-a".into(),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-b".into(),
                })),
            }),
            committer: None,
            message: String::new(),
            options: Some(MergeOptions {
                fast_forward: merge_options::FastForwardMode::MergeFastForwardModeOnly as i32,
                ..Default::default()
            }),
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        merge_result::Status::MergeResultStatusAborted as i32
    );
    assert!(result.commit.is_none());
}

#[tokio::test]
async fn test_list_merge_conflicts() {
    let (dir, _gb) = common::setup_bare_repo_with_conflict();
    let svc = common::setup_service(dir.path());
    let result = svc
        .list_merge_conflicts(tonic::Request::new(ListMergeConflictsRequest {
            repository: Some(hdr()),
            target: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-a".into(),
                })),
            }),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-b".into(),
                })),
            }),
            pagination: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert!(!result.conflicts.is_empty(), "should list conflicted files");
    assert!(
        result.conflicts.iter().any(|c| c.path == "file.txt"),
        "file.txt should be conflicted"
    );
}

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

    let result = svc
        .resolve_merge_conflicts(tonic::Request::new(ResolveMergeConflictsRequest {
            repository: Some(hdr()),
            target_branch: "branch-a".into(),
            source: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-b".into(),
                })),
            }),
            resolutions: vec![ResolveMergeConflict {
                path: "file.txt".into(),
                content: b"resolved content\n".to_vec(),
            }],
            committer: None,
            message: "resolved conflicts".into(),
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        merge_result::Status::MergeResultStatusMerged as i32
    );
    assert!(result.commit.is_some());

    let blob = svc
        .get_blob(tonic::Request::new(GetBlobRequest {
            repository: Some(hdr()),
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "branch-a".into(),
                })),
            }),
            path: "file.txt".into(),
            oid: None,
            max_bytes: 0,
        }))
        .await
        .unwrap()
        .into_inner();
    assert_eq!(String::from_utf8_lossy(&blob.data), "resolved content\n");
}

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

    svc.create_commit(tonic::Request::new(CreateCommitRequest {
        repository: Some(hdr()),
        branch: "feature".into(),
        message: "feature work".into(),
        author: None,
        committer: None,
        actions: vec![CreateCommitAction {
            action: create_commit_action::Action::CreateCommitActionCreate as i32,
            file_path: "feature.txt".into(),
            previous_path: String::new(),
            content: b"feature content".to_vec(),
            encoding: String::new(),
            executable: false,
            last_commit_oid: None,
        }],
        start_revision: Some(ObjectSelector {
            selector: Some(object_selector::Selector::Revision(ObjectName {
                revision: "feature".into(),
            })),
        }),
        force: false,
        trailers: vec![],
    }))
    .await
    .unwrap();

    let result = svc
        .rebase(tonic::Request::new(RebaseRequest {
            repository: Some(hdr()),
            branch: "feature".into(),
            upstream: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "main".into(),
                })),
            }),
            committer: None,
        }))
        .await
        .unwrap()
        .into_inner();

    assert_eq!(
        result.status,
        rebase_result::Status::RebaseResultStatusRebased as i32
    );
    assert!(result.head.is_some());

    let blob = svc
        .get_blob(tonic::Request::new(GetBlobRequest {
            repository: Some(hdr()),
            revision: Some(ObjectSelector {
                selector: Some(object_selector::Selector::Revision(ObjectName {
                    revision: "feature".into(),
                })),
            }),
            path: "feature.txt".into(),
            oid: None,
            max_bytes: 0,
        }))
        .await
        .unwrap()
        .into_inner();
    assert_eq!(String::from_utf8_lossy(&blob.data), "feature content");
}