use std::fs;
use threefold_marketplace::services::ssh_key_service::SSHKeyService;

/// Integration test for complete SSH Key UI workflow
/// Tests: Create SSH key → Test set default, edit, delete buttons
#[tokio::test]
async fn test_ssh_key_complete_ui_workflow() {
    println!("🔧 Testing Complete SSH Key UI Workflow");
    
    // Test user
    let test_user_email = "ssh_ui_test@example.com";
    let test_ssh_key = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIG2DBmFDHHXEXAMP1EKfgzrFQJ7CVOXXJwJQ6nKZZJhC test_ui_key@example.com";
    
    // Clean up any existing test data
    let user_data_path = format!("user_data/{}.json", test_user_email.replace("@", "_at_").replace(".", "_"));
    let _ = fs::remove_file(&user_data_path);
    
    // Step 1: Create SSH Key Service
    println!("🔧 Step 1: Testing SSH Key Service Creation");
    let ssh_service = SSHKeyService::builder()
        .build()
        .expect("Failed to build SSH key service");
    println!("✅ SSH Key Service: Created successfully");
    
    // Step 2: Add SSH Key (like the create form)
    println!("🔧 Step 2: Creating SSH Key (simulating UI create)");
    let created_key = ssh_service.add_ssh_key(
        test_user_email,
        "Test UI Key",
        test_ssh_key,
        false
    ).expect("Failed to add SSH key");
    
    let created_key_id = created_key.id.clone();
    println!("✅ SSH Key Created: ID = {}", created_key_id);
    
    // Step 3: Get all keys to verify creation worked
    println!("🔧 Step 3: Verifying SSH Key List");
    let all_keys = ssh_service.get_user_ssh_keys(test_user_email);
    assert!(!all_keys.is_empty(), "SSH key list should not be empty");
    assert_eq!(all_keys.len(), 1, "Should have exactly 1 SSH key");
    println!("✅ SSH Key List: {} keys found", all_keys.len());
    
    // Step 4: Test Set Default (simulating set default button)
    println!("🔧 Step 4: Testing Set Default Button Operation");
    match ssh_service.set_default_ssh_key(test_user_email, &created_key_id) {
        Ok(()) => {
            println!("✅ Set Default Button: WORKING");
            
            // Verify it worked
            let updated_keys = ssh_service.get_user_ssh_keys(test_user_email);
            let default_key = updated_keys.iter().find(|k| k.is_default);
            assert!(default_key.is_some(), "Should have a default key");
            assert_eq!(default_key.unwrap().id, created_key_id, "Default key ID should match");
            println!("✅ Set Default Verification: SUCCESS");
        }
        Err(e) => {
            println!("❌ Set Default Button: FAILED - {}", e);
            panic!("Set default button should work");
        }
    }
    
    // Step 5: Test Update/Edit (simulating edit button)
    println!("🔧 Step 5: Testing Edit Button Operation");
    match ssh_service.update_ssh_key(test_user_email, &created_key_id, Some("Updated UI Key Name"), None) {
        Ok(updated_key) => {
            println!("✅ Edit Button: WORKING");
            assert_eq!(updated_key.name, "Updated UI Key Name", "Name should be updated");
            assert_eq!(updated_key.id, created_key_id, "Key ID should remain same");
            println!("✅ Edit Verification: SUCCESS");
        }
        Err(e) => {
            println!("❌ Edit Button: FAILED - {}", e);
            panic!("Edit button should work");
        }
    }
    
    // Step 6: Test Delete (simulating delete button)
    println!("🔧 Step 6: Testing Delete Button Operation");
    match ssh_service.delete_ssh_key(test_user_email, &created_key_id) {
        Ok(()) => {
            println!("✅ Delete Button: WORKING");
            
            // Verify deletion worked
            let remaining_keys = ssh_service.get_user_ssh_keys(test_user_email);
            assert!(remaining_keys.is_empty(), "Should have no keys after deletion");
            println!("✅ Delete Verification: SUCCESS (0 keys remaining)");
        }
        Err(e) => {
            println!("❌ Delete Button: FAILED - {}", e);
            panic!("Delete button should work");
        }
    }
    
    // Clean up test data
    let _ = fs::remove_file(&user_data_path);
    println!("🧹 Cleaned up test user data: {}", user_data_path);
    
    // Summary
    println!("🎯 COMPLETE UI WORKFLOW TEST SUMMARY:");
    println!("✅ SSH Key Creation: WORKING");
    println!("✅ Set Default Button Backend: WORKING");
    println!("✅ Edit Button Backend: WORKING");
    println!("✅ Delete Button Backend: WORKING");
    println!("");
    println!("🔍 NEXT: Test frontend button click handlers and form data");
}

/// Test the specific scenario that might be failing in the UI
#[tokio::test]
async fn test_ssh_key_button_scenarios() {
    println!("🔧 Testing SSH Key Button Error Scenarios");
    
    let test_user_email = "ssh_button_test@example.com";
    let test_ssh_key = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIE8GmPXXXamp1eKfgzrFQJ7CVOXXXJQ6nKZZJhC button_test@example.com";
    
    // Clean up any existing test data
    let user_data_path = format!("user_data/{}.json", test_user_email.replace("@", "_at_").replace(".", "_"));
    let _ = fs::remove_file(&user_data_path);
    
    let ssh_service = SSHKeyService::builder()
        .build()
        .expect("Failed to build SSH key service");
    
    // Create a test key
    let created_key = ssh_service.add_ssh_key(
        test_user_email,
        "Button Test Key",
        test_ssh_key,
        false
    ).expect("Failed to add SSH key");
    
    println!("🔧 Testing with Key ID: {}", created_key.id);
    
    // Test scenario 1: Set default with empty key ID
    println!("🔧 Test 1: Set default with empty key ID");
    match ssh_service.set_default_ssh_key(test_user_email, "") {
        Ok(()) => println!("❌ Should have failed with empty key ID"),
        Err(e) => println!("✅ Correctly failed with empty key ID: {}", e),
    }
    
    // Test scenario 2: Set default with invalid key ID  
    println!("🔧 Test 2: Set default with invalid key ID");
    match ssh_service.set_default_ssh_key(test_user_email, "invalid-key-id") {
        Ok(()) => println!("❌ Should have failed with invalid key ID"),
        Err(e) => println!("✅ Correctly failed with invalid key ID: {}", e),
    }
    
    // Test scenario 3: Set default with correct key ID
    println!("🔧 Test 3: Set default with correct key ID");
    match ssh_service.set_default_ssh_key(test_user_email, &created_key.id) {
        Ok(()) => println!("✅ Set default worked with correct key ID"),
        Err(e) => println!("❌ Set default should have worked: {}", e),
    }
    
    // Test scenario 4: Update with invalid key ID
    println!("🔧 Test 4: Update with invalid key ID");
    match ssh_service.update_ssh_key(test_user_email, "invalid-key-id", Some("New Name"), None) {
        Ok(_) => println!("❌ Should have failed with invalid key ID"),
        Err(e) => println!("✅ Correctly failed with invalid key ID: {}", e),
    }
    
    // Test scenario 5: Delete with invalid key ID
    println!("🔧 Test 5: Delete with invalid key ID");
    match ssh_service.delete_ssh_key(test_user_email, "invalid-key-id") {
        Ok(()) => println!("❌ Should have failed with invalid key ID"),
        Err(e) => println!("✅ Correctly failed with invalid key ID: {}", e),
    }
    
    // Clean up
    let _ = ssh_service.delete_ssh_key(test_user_email, &created_key.id);
    let _ = fs::remove_file(&user_data_path);
    
    println!("🎯 BUTTON SCENARIO TEST COMPLETED");
    println!("🔍 If UI buttons are still failing, the issue is likely:");
    println!("   1. Key ID not being passed correctly from JavaScript");
    println!("   2. JavaScript event handlers not attaching properly");  
    println!("   3. Form data not being constructed correctly");
}