//! Git-project linking via the git_repos table.

use crate::harness::TestHarness;
use makenotwork::db::UserId;
use serde_json::Value;

/// Helper: create a creator with a project, return (user_id, project_id).
async fn setup_creator_with_project(
    h: &mut TestHarness,
    username: &str,
    slug: &str,
    title: &str,
) -> (UserId, String) {
    let user_id = h
        .signup(username, &format!("{}@example.com", username), "password123")
        .await;
    h.grant_creator(user_id).await;
    h.client.post_form("/logout", "").await;
    h.login(username, "password123").await;

    let resp = h
        .client
        .post_form(
            "/api/projects",
            &format!("slug={}&title={}", slug, title.replace(' ', "+")),
        )
        .await;
    assert!(resp.status.is_success(), "Create project failed: {}", resp.text);
    let project: Value = resp.json();
    let project_id = project["id"].as_str().unwrap().to_string();

    (user_id, project_id)
}

/// DB round-trip: create a git_repos row, look up by user+name, link/unlink project.
#[tokio::test]
async fn git_repo_db_round_trip() {
    let mut h = TestHarness::new().await;
    let (user_id, project_id) = setup_creator_with_project(&mut h, "gituser3", "proj3", "Project Three").await;
    let project_uuid = project_id.parse::<uuid::Uuid>().unwrap();

    // Initially no repo
    let found: Option<(uuid::Uuid,)> = sqlx::query_as(
        "SELECT id FROM git_repos WHERE user_id = $1 AND name = $2"
    )
        .bind(uuid::Uuid::from(user_id))
        .bind("my-repo")
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert!(found.is_none(), "Should find nothing before creating");

    // Create repo
    sqlx::query("INSERT INTO git_repos (user_id, name) VALUES ($1, $2)")
        .bind(uuid::Uuid::from(user_id))
        .bind("my-repo")
        .execute(&h.db)
        .await
        .unwrap();

    // Lookup succeeds
    let found: Option<(uuid::Uuid,)> = sqlx::query_as(
        "SELECT id FROM git_repos WHERE user_id = $1 AND name = $2"
    )
        .bind(uuid::Uuid::from(user_id))
        .bind("my-repo")
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert!(found.is_some(), "Should find repo after creating");
    let repo_id = found.unwrap().0;

    // Link to project
    sqlx::query("UPDATE git_repos SET project_id = $2 WHERE id = $1")
        .bind(repo_id)
        .bind(project_uuid)
        .execute(&h.db)
        .await
        .unwrap();

    // Verify link
    let linked: Option<(uuid::Uuid,)> = sqlx::query_as(
        "SELECT project_id FROM git_repos WHERE id = $1"
    )
        .bind(repo_id)
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert_eq!(linked.unwrap().0, project_uuid);

    // Unlink
    sqlx::query("UPDATE git_repos SET project_id = NULL WHERE id = $1")
        .bind(repo_id)
        .execute(&h.db)
        .await
        .unwrap();

    let unlinked: Option<(Option<uuid::Uuid>,)> = sqlx::query_as(
        "SELECT project_id FROM git_repos WHERE id = $1"
    )
        .bind(repo_id)
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert!(unlinked.unwrap().0.is_none(), "Should be unlinked");
}

/// The unique constraint prevents duplicate (user_id, name) in git_repos.
#[tokio::test]
async fn git_repo_unique_constraint() {
    let mut h = TestHarness::new().await;
    let (user_id, _project_id) = setup_creator_with_project(&mut h, "gituser4", "proj4a", "Project 4A").await;

    // Create first repo
    sqlx::query("INSERT INTO git_repos (user_id, name) VALUES ($1, $2)")
        .bind(uuid::Uuid::from(user_id))
        .bind("shared-repo")
        .execute(&h.db)
        .await
        .unwrap();

    // Duplicate should fail
    let result = sqlx::query("INSERT INTO git_repos (user_id, name) VALUES ($1, $2)")
        .bind(uuid::Uuid::from(user_id))
        .bind("shared-repo")
        .execute(&h.db)
        .await;
    assert!(result.is_err(), "Should reject duplicate (user_id, name)");

    // Different user CAN have the same repo name
    let user2_id = h
        .signup("gituser4b", "gituser4b@example.com", "password123")
        .await;

    sqlx::query("INSERT INTO git_repos (user_id, name) VALUES ($1, $2)")
        .bind(uuid::Uuid::from(user2_id))
        .bind("shared-repo")
        .execute(&h.db)
        .await
        .expect("Different users should be able to have the same repo name");
}

/// Multiple repos can link to the same project.
#[tokio::test]
async fn multiple_repos_link_to_same_project() {
    let mut h = TestHarness::new().await;
    let (user_id, project_id) = setup_creator_with_project(&mut h, "gituser7", "proj7", "Project Seven").await;
    let project_uuid = project_id.parse::<uuid::Uuid>().unwrap();

    // Create two repos
    sqlx::query("INSERT INTO git_repos (user_id, name, project_id) VALUES ($1, $2, $3)")
        .bind(uuid::Uuid::from(user_id))
        .bind("repo-a")
        .bind(project_uuid)
        .execute(&h.db)
        .await
        .unwrap();

    sqlx::query("INSERT INTO git_repos (user_id, name, project_id) VALUES ($1, $2, $3)")
        .bind(uuid::Uuid::from(user_id))
        .bind("repo-b")
        .bind(project_uuid)
        .execute(&h.db)
        .await
        .unwrap();

    // Both should be linked
    let count: (i64,) = sqlx::query_as(
        "SELECT COUNT(*) FROM git_repos WHERE project_id = $1"
    )
        .bind(project_uuid)
        .fetch_one(&h.db)
        .await
        .unwrap();
    assert_eq!(count.0, 2, "Both repos should be linked to the project");
}

/// Link/unlink repos via the API endpoints.
#[tokio::test]
async fn link_unlink_repo_via_api() {
    let mut h = TestHarness::new().await;
    let (user_id, project_id) = setup_creator_with_project(&mut h, "gituser8", "proj8", "Project Eight").await;

    // Create a repo in the DB first (simulates auto-registration)
    sqlx::query("INSERT INTO git_repos (user_id, name) VALUES ($1, $2)")
        .bind(uuid::Uuid::from(user_id))
        .bind("api-repo")
        .execute(&h.db)
        .await
        .unwrap();

    // Link via API
    let resp = h
        .client
        .post_json(
            &format!("/api/projects/{}/repos", project_id),
            r#"{"name": "api-repo"}"#,
        )
        .await;
    assert!(resp.status.is_success(), "Link should succeed: {}", resp.text);

    // Verify link in DB
    let linked: Option<(uuid::Uuid,)> = sqlx::query_as(
        "SELECT project_id FROM git_repos WHERE user_id = $1 AND name = $2"
    )
        .bind(uuid::Uuid::from(user_id))
        .bind("api-repo")
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert_eq!(
        linked.unwrap().0,
        project_id.parse::<uuid::Uuid>().unwrap(),
        "Repo should be linked to project"
    );

    // Unlink via API
    let resp = h
        .client
        .delete(&format!("/api/projects/{}/repos/api-repo", project_id))
        .await;
    assert!(resp.status.is_success(), "Unlink should succeed: {}", resp.text);

    // Verify unlinked
    let unlinked: Option<(Option<uuid::Uuid>,)> = sqlx::query_as(
        "SELECT project_id FROM git_repos WHERE user_id = $1 AND name = $2"
    )
        .bind(uuid::Uuid::from(user_id))
        .bind("api-repo")
        .fetch_optional(&h.db)
        .await
        .unwrap();
    assert!(unlinked.unwrap().0.is_none(), "Repo should be unlinked");
}

/// Linking a repo that doesn't exist should fail.
#[tokio::test]
async fn link_nonexistent_repo_fails() {
    let mut h = TestHarness::new().await;
    let (_user_id, project_id) = setup_creator_with_project(&mut h, "gituser9", "proj9", "Project Nine").await;

    let resp = h
        .client
        .post_json(
            &format!("/api/projects/{}/repos", project_id),
            r#"{"name": "no-such-repo"}"#,
        )
        .await;
    assert_eq!(resp.status, 422, "Should reject linking nonexistent repo");
}

/// Project page should NOT show repo links when none are linked.
#[tokio::test]
async fn project_page_without_git_link() {
    let mut h = TestHarness::new().await;
    let (_user_id, project_id) = setup_creator_with_project(&mut h, "gituser5", "proj5", "Project Five").await;

    // Make project public
    h.client
        .put_json(
            &format!("/api/projects/{}", project_id),
            r#"{"is_public": true}"#,
        )
        .await;

    h.client.post_form("/logout", "").await;

    let resp = h.client.get("/p/proj5").await;
    assert_eq!(resp.status, 200);
    assert!(
        resp.text.contains("Project Five"),
        "Project page should render"
    );
}

/// Project page should show repo links when repos are linked.
#[tokio::test]
async fn project_page_with_git_link() {
    let mut h = TestHarness::new().await;
    let (user_id, project_id) = setup_creator_with_project(&mut h, "gituser6", "proj6", "Project Six").await;
    let project_uuid = project_id.parse::<uuid::Uuid>().unwrap();

    // Make project public
    h.client
        .put_json(
            &format!("/api/projects/{}", project_id),
            r#"{"is_public": true}"#,
        )
        .await;

    // Create and link a repo
    sqlx::query("INSERT INTO git_repos (user_id, name, project_id) VALUES ($1, $2, $3)")
        .bind(uuid::Uuid::from(user_id))
        .bind("my-repo")
        .bind(project_uuid)
        .execute(&h.db)
        .await
        .unwrap();

    h.client.post_form("/logout", "").await;

    let resp = h.client.get("/p/proj6").await;
    assert_eq!(resp.status, 200);
    // git_repos_path is not configured in tests, so no repo links will appear.
    // This correctly tests that the page renders with repos in the DB.
    assert!(
        resp.text.contains("Project Six"),
        "Project page should render with git repos in DB"
    );
}