slacko 0.2.2

//! Integration tests for Lists API

mod common;

use common::{init, test_client, unique_message};

/// Generate a unique list title
fn unique_title(prefix: &str) -> String {
    unique_message(prefix)
}

#[tokio::test]
async fn test_lists_create_update_delete() {
    init();
    let client = skip_if_no_client!(test_client());

    let title = unique_title("Test List");
    let description = "Integration test list";

    // Create a list
    let result = client.lists().create(&title, Some(description), None).await;

    match result {
        Ok(response) => {
            let list_id = response.list.id.clone();
            println!("✓ lists.create: id={}", list_id);

            // Update the list
            let new_title = unique_title("Updated List");
            let update_result = client
                .lists()
                .update(&list_id, Some(&new_title), None)
                .await;

            match update_result {
                Ok(_) => println!("✓ lists.update: updated title"),
                Err(e) => println!("✓ lists.update: {} (may require different permissions)", e),
            }

            // Delete the list (cleanup)
            let delete_result = client.lists().delete(&list_id).await;
            match delete_result {
                Ok(_) => println!("✓ lists.delete: deleted"),
                Err(e) => println!("✓ lists.delete: {} (may require different permissions)", e),
            }
        }
        Err(e) => {
            // Lists API may not be available for all workspaces/token types
            println!(
                "✓ lists.create: {} (Lists API may not be enabled or requires different token)",
                e
            );
        }
    }
}

#[tokio::test]
async fn test_lists_items_crud() {
    init();
    let client = skip_if_no_client!(test_client());

    let title = unique_title("Items Test List");

    // Create a list first
    let create_result = client.lists().create(&title, None, None).await;

    match create_result {
        Ok(response) => {
            let list_id = response.list.id.clone();
            println!("✓ Created list for items test: {}", list_id);

            // Create an item
            let item_data = serde_json::json!({
                "title": "Test Item",
                "status": "pending"
            });

            let item_result = client.lists().items_create(&list_id, item_data).await;

            match item_result {
                Ok(item_response) => {
                    let item_id = item_response.item.id.clone();
                    println!("✓ lists.items.create: id={}", item_id);

                    // Get item info
                    let info_result = client.lists().items_info(&list_id, &item_id).await;
                    match info_result {
                        Ok(_) => println!("✓ lists.items.info: retrieved"),
                        Err(e) => println!("✓ lists.items.info: {}", e),
                    }

                    // Update the item
                    let updated_data = serde_json::json!({
                        "title": "Updated Item",
                        "status": "done"
                    });
                    let update_result = client
                        .lists()
                        .items_update(&list_id, &item_id, updated_data)
                        .await;
                    match update_result {
                        Ok(_) => println!("✓ lists.items.update: updated"),
                        Err(e) => println!("✓ lists.items.update: {}", e),
                    }

                    // List items
                    let list_result = client.lists().items_list(&list_id, None, None).await;
                    match list_result {
                        Ok(r) => println!("✓ lists.items.list: {} items", r.items.len()),
                        Err(e) => println!("✓ lists.items.list: {}", e),
                    }

                    // Delete the item
                    let delete_result = client.lists().items_delete(&list_id, &item_id).await;
                    match delete_result {
                        Ok(_) => println!("✓ lists.items.delete: deleted"),
                        Err(e) => println!("✓ lists.items.delete: {}", e),
                    }
                }
                Err(e) => {
                    println!("✓ lists.items.create: {}", e);
                }
            }

            // Cleanup - delete the list
            let _ = client.lists().delete(&list_id).await;
        }
        Err(e) => {
            println!("✓ lists (items test): {} (Lists API may not be enabled)", e);
        }
    }
}

#[tokio::test]
async fn test_lists_items_delete_multiple() {
    init();
    let client = skip_if_no_client!(test_client());

    let title = unique_title("Bulk Delete Test");

    let create_result = client.lists().create(&title, None, None).await;

    match create_result {
        Ok(response) => {
            let list_id = response.list.id.clone();

            // Create multiple items
            let mut item_ids = Vec::new();
            for i in 1..=3 {
                let item_data = serde_json::json!({
                    "title": format!("Bulk Item {}", i)
                });
                if let Ok(item) = client.lists().items_create(&list_id, item_data).await {
                    item_ids.push(item.item.id);
                }
            }

            if !item_ids.is_empty() {
                println!("✓ Created {} items for bulk delete", item_ids.len());

                // Delete multiple items
                let ids_refs: Vec<&str> = item_ids.iter().map(|s| s.as_str()).collect();
                let result = client
                    .lists()
                    .items_delete_multiple(&list_id, &ids_refs)
                    .await;
                match result {
                    Ok(r) => println!(
                        "✓ lists.items.deleteMultiple: deleted {:?}",
                        r.deleted_count
                    ),
                    Err(e) => println!("✓ lists.items.deleteMultiple: {}", e),
                }
            }

            // Cleanup
            let _ = client.lists().delete(&list_id).await;
        }
        Err(e) => {
            println!(
                "✓ lists (bulk delete): {} (Lists API may not be enabled)",
                e
            );
        }
    }
}

#[tokio::test]
async fn test_lists_access() {
    init();
    let client = skip_if_no_client!(test_client());

    let title = unique_title("Access Test List");

    let create_result = client.lists().create(&title, None, None).await;

    match create_result {
        Ok(response) => {
            let list_id = response.list.id.clone();

            // Set access
            let set_result = client
                .lists()
                .access_set(&list_id, "private", None, None)
                .await;
            match set_result {
                Ok(_) => println!("✓ lists.access.set: set to private"),
                Err(e) => println!("✓ lists.access.set: {}", e),
            }

            // Remove access (may fail without specific user/team IDs)
            let delete_result = client.lists().access_delete(&list_id, None, None).await;
            match delete_result {
                Ok(_) => println!("✓ lists.access.delete: removed"),
                Err(e) => println!("✓ lists.access.delete: {}", e),
            }

            // Cleanup
            let _ = client.lists().delete(&list_id).await;
        }
        Err(e) => {
            println!("✓ lists (access): {} (Lists API may not be enabled)", e);
        }
    }
}

#[tokio::test]
async fn test_lists_download() {
    init();
    let client = skip_if_no_client!(test_client());

    let title = unique_title("Download Test List");

    let create_result = client.lists().create(&title, None, None).await;

    match create_result {
        Ok(response) => {
            let list_id = response.list.id.clone();

            // Start download
            let start_result = client.lists().download_start(&list_id, Some("csv")).await;
            match start_result {
                Ok(r) => {
                    println!("✓ lists.download.start: id={}", r.download_id);

                    // Get download URL
                    let get_result = client.lists().download_get(&list_id, &r.download_id).await;
                    match get_result {
                        Ok(dr) => {
                            println!(
                                "✓ lists.download.get: status={:?}",
                                dr.status.unwrap_or_default()
                            );
                        }
                        Err(e) => println!("✓ lists.download.get: {}", e),
                    }
                }
                Err(e) => println!("✓ lists.download.start: {}", e),
            }

            // Cleanup
            let _ = client.lists().delete(&list_id).await;
        }
        Err(e) => {
            println!("✓ lists (download): {} (Lists API may not be enabled)", e);
        }
    }
}