//! Integration tests for SqliteProjectRepository.

mod common;

use goingson_core::{NewProject, ProjectRepository, ProjectStatus, ProjectType, UpdateProject};
use goingson_db_sqlite::SqliteProjectRepository;

#[tokio::test]
async fn test_create_and_get_project() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteProjectRepository::new(pool);

    let new_project = NewProject {
        name: "Test Project".to_string(),
        description: "A test project".to_string(),
        project_type: ProjectType::SideProject,
        status: ProjectStatus::Active,
    };

    let created = repo.create(user_id, new_project).await.expect("Failed to create project");
    assert_eq!(created.name, "Test Project");
    assert_eq!(created.description, "A test project");
    assert_eq!(created.project_type, ProjectType::SideProject);
    assert_eq!(created.status, ProjectStatus::Active);

    let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get project");
    assert!(fetched.is_some());
    let fetched = fetched.unwrap();
    assert_eq!(fetched.id, created.id);
    assert_eq!(fetched.name, "Test Project");
}

#[tokio::test]
async fn test_list_projects() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteProjectRepository::new(pool);

    // Create multiple projects
    for i in 1..=3 {
        let new_project = NewProject {
            name: format!("Project {}", i),
            description: format!("Description {}", i),
            project_type: ProjectType::Job,
            status: ProjectStatus::Active,
        };
        repo.create(user_id, new_project).await.expect("Failed to create project");
    }

    let projects = repo.list_all(user_id).await.expect("Failed to list projects");
    assert_eq!(projects.len(), 3);
}

#[tokio::test]
async fn test_update_project() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteProjectRepository::new(pool);

    let new_project = NewProject {
        name: "Original Name".to_string(),
        description: "Original description".to_string(),
        project_type: ProjectType::Job,
        status: ProjectStatus::Active,
    };

    let created = repo.create(user_id, new_project).await.expect("Failed to create project");

    let update = UpdateProject {
        name: "Updated Name".to_string(),
        description: "Updated description".to_string(),
        project_type: ProjectType::Company,
        status: ProjectStatus::OnHold,
    };
    let updated = repo.update(
        created.id,
        user_id,
        update,
    ).await.expect("Failed to update project");

    assert!(updated.is_some());
    let updated = updated.unwrap();
    assert_eq!(updated.name, "Updated Name");
    assert_eq!(updated.description, "Updated description");
    assert_eq!(updated.project_type, ProjectType::Company);
    assert_eq!(updated.status, ProjectStatus::OnHold);
}

#[tokio::test]
async fn test_delete_project() {
    let pool = common::setup_test_db().await;
    let user_id = common::create_test_user(&pool).await;
    let repo = SqliteProjectRepository::new(pool);

    let new_project = NewProject {
        name: "To Delete".to_string(),
        description: "Will be deleted".to_string(),
        project_type: ProjectType::Other,
        status: ProjectStatus::Active,
    };

    let created = repo.create(user_id, new_project).await.expect("Failed to create project");

    let deleted = repo.delete(created.id, user_id).await.expect("Failed to delete project");
    assert!(deleted);

    let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get project");
    assert!(fetched.is_none());
}

#[tokio::test]
async fn test_user_isolation() {
    let pool = common::setup_test_db().await;
    let user1 = common::create_test_user(&pool).await;
    let user2 = common::create_test_user(&pool).await;
    let repo = SqliteProjectRepository::new(pool);

    let project = NewProject {
        name: "User 1 Project".to_string(),
        description: "Belongs to user 1".to_string(),
        project_type: ProjectType::Job,
        status: ProjectStatus::Active,
    };

    let created = repo.create(user1, project).await.expect("Failed to create project");

    // User 1 can see their project
    let user1_projects = repo.list_all(user1).await.expect("Failed to list");
    assert_eq!(user1_projects.len(), 1);

    // User 2 cannot see user 1's project
    let user2_projects = repo.list_all(user2).await.expect("Failed to list");
    assert_eq!(user2_projects.len(), 0);

    // User 2 cannot access by ID either
    let fetched = repo.get_by_id(created.id, user2).await.expect("Failed to get");
    assert!(fetched.is_none());
}