//! Public Access Tests
//! 
//! Tests for functionality available without authentication:
//! - Information pages (/docs, /privacy, /terms, /about, /contact)
//! - Anonymous marketplace browsing
//! - Anonymous cart functionality
//! - Search and filtering

use crate::utils::*;
use crate::environment::*;
use tokio_test;

/// Test all public information pages are accessible
#[tokio::test]
#[serial_test::serial]
async fn test_public_information_pages() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing public information pages");

    // Test each information page
    let pages = vec![
        ("/docs", "Documentation"),
        ("/privacy", "Privacy"),
        ("/terms", "Terms"),
        ("/about", "About"),
        ("/contact", "Contact"),
    ];

    for (url, expected_title_part) in pages {
        log::info!("Testing page: {}", url);
        
        // Navigate to page
        helper.browser.navigate_to(url).await?;
        
        // Assert page loads successfully
        helper.assert_page_loaded(expected_title_part).await?;
        
        // Take screenshot
        let page_name = url.trim_start_matches('/');
        helper.take_screenshot(&format!("public_page_{}", page_name)).await?;
        
        // Verify page contains expected content indicators
        match url {
            "/docs" => {
                assert!(helper.browser.element_exists(".documentation, .docs-content, h1").await);
            }
            "/privacy" => {
                assert!(helper.browser.element_exists(".privacy-policy, .legal-content, h1").await);
            }
            "/terms" => {
                assert!(helper.browser.element_exists(".terms-conditions, .legal-content, h1").await);
            }
            "/about" => {
                assert!(helper.browser.element_exists(".about-content, .marketplace-info, h1").await);
            }
            "/contact" => {
                assert!(helper.browser.element_exists(".contact-info, .contact-form, h1").await);
            }
            _ => {}
        }
    }

    log::info!("All public information pages test completed successfully");
    Ok(())
}

/// Test anonymous marketplace browsing
#[tokio::test]
#[serial_test::serial]
async fn test_anonymous_marketplace_browsing() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing anonymous marketplace browsing");

    // Test main marketplace page
    helper.browser.navigate_to("/marketplace").await?;
    helper.assert_page_loaded("Marketplace").await?;
    
    // Verify marketplace loads without authentication
    assert!(helper.browser.element_exists(".marketplace, .product-grid, .category-nav").await);
    helper.take_screenshot("marketplace_anonymous").await?;

    // Test each marketplace category
    let categories = vec![
        ("/marketplace/compute", "compute resources"),
        ("/marketplace/mycelium_nodes", "mycelium_nodes"),
        ("/marketplace/gateways", "gateways"),
        ("/marketplace/applications", "applications"),
        ("/marketplace/services", "services"),
    ];

    for (url, category_name) in categories {
        log::info!("Testing marketplace category: {}", category_name);
        
        helper.browser.navigate_to(url).await?;
        
        // Wait for category content to load
        helper.browser.wait_for_element(".category-content, .product-list, .marketplace").await?;
        
        // Verify category-specific elements exist
        match url {
            "/marketplace/compute" => {
                // Should show VM/slice options
                helper.browser.wait_for_element(".compute-resources, .vm-options, .slice-list").await.ok();
            }
            "/marketplace/mycelium_nodes" => {
                // Should show node listings
                helper.browser.wait_for_element(".node-listings, .server-list, .mycelium-node-grid").await.ok();
            }
            "/marketplace/gateways" => {
                // Should show gateway services
                helper.browser.wait_for_element(".gateway-services, .mycelium-gateways").await.ok();
            }
            "/marketplace/applications" => {
                // Should show app listings
                helper.browser.wait_for_element(".app-grid, .application-list, .published-apps").await.ok();
            }
            "/marketplace/services" => {
                // Should show service listings
                helper.browser.wait_for_element(".service-list, .professional-services").await.ok();
            }
            _ => {}
        }
        
        let category_clean = category_name.replace(" ", "_");
        helper.take_screenshot(&format!("marketplace_{}", category_clean)).await?;
    }

    log::info!("Anonymous marketplace browsing test completed successfully");
    Ok(())
}

/// Test anonymous cart functionality
#[tokio::test]
#[serial_test::serial]
async fn test_anonymous_cart_functionality() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing anonymous cart functionality");

    // Navigate to marketplace
    helper.browser.navigate_to("/marketplace").await?;
    
    // Try to add item to cart (if products are available)
    if helper.browser.element_exists(".add-to-cart, .product-card").await {
        // Click first add to cart button found
        helper.browser.click(".add-to-cart, .product-card .btn-primary").await?;
        
        // Should show some indication of cart update
        helper.browser.wait_for_element(".cart-updated, .notification, .alert").await.ok();
    }
    
    // Navigate to anonymous cart
    helper.navigate_to_cart().await?;
    helper.assert_page_loaded("Cart").await?;
    
    // Verify cart page shows for non-authenticated users
    assert!(helper.browser.element_exists(".cart, .cart-content, .shopping-cart").await);
    helper.take_screenshot("anonymous_cart").await?;
    
    // Check for login prompt when trying to checkout
    if helper.browser.element_exists(".checkout-btn, .proceed-checkout").await {
        helper.browser.click(".checkout-btn, .proceed-checkout").await?;
        
        // Should redirect to login or show login prompt
        helper.browser.wait_for_element(".login-form, .auth-required, .login-prompt").await.ok();
        helper.take_screenshot("checkout_login_prompt").await?;
    }

    log::info!("Anonymous cart functionality test completed successfully");
    Ok(())
}

/// Test marketplace search and filtering
#[tokio::test]
#[serial_test::serial]
async fn test_marketplace_search_and_filtering() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing marketplace search and filtering");

    // Navigate to marketplace
    helper.browser.navigate_to("/marketplace").await?;
    
    // Test search functionality
    if helper.browser.element_exists(".search-input, input[type='search']").await {
        helper.browser.type_text(".search-input, input[type='search']", "test").await?;
        
        // Submit search or wait for auto-search
        if helper.browser.element_exists(".search-btn, .search-submit").await {
            helper.browser.click(".search-btn, .search-submit").await?;
        }
        
        // Wait for search results
        helper.browser.wait_for_element(".search-results, .product-grid, .filtered-results").await.ok();
        helper.take_screenshot("marketplace_search_results").await?;
    }
    
    // Test category filtering
    if helper.browser.element_exists(".category-filter, .filter-category").await {
        let filters = helper.browser.find_elements(".category-filter option, .filter-btn").await.ok();
        
        if let Some(filters) = filters {
            if filters.len() > 1 {
                // Click first filter option
                filters[1].click().await.ok();
                
                // Wait for filtered results
                helper.browser.wait_for_element(".filtered-results, .category-products").await.ok();
                helper.take_screenshot("marketplace_filtered_results").await?;
            }
        }
    }
    
    // Test price filtering if available
    if helper.browser.element_exists(".price-filter, .price-range").await {
        helper.take_screenshot("marketplace_price_filter").await?;
    }

    log::info!("Marketplace search and filtering test completed successfully");
    Ok(())
}

/// Test product details pages
#[tokio::test]
#[serial_test::serial]
async fn test_product_details_pages() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing product details pages");

    // Navigate to marketplace
    helper.browser.navigate_to("/marketplace").await?;
    
    // Find and click on a product (if available)
    if helper.browser.element_exists(".product-card, .product-item").await {
        helper.browser.click(".product-card, .product-item").await?;
        
        // Wait for product details page
        helper.browser.wait_for_element(".product-details, .product-info, .item-details").await.ok();
        
        // Verify product details elements
        let expected_elements = vec![
            ".product-name, .item-title",
            ".product-price, .price-info",
            ".product-description, .item-description",
        ];
        
        for element in expected_elements {
            if helper.browser.element_exists(element).await {
                log::info!("Found product detail element: {}", element);
            }
        }
        
        helper.take_screenshot("product_details_page").await?;
        
        // Test product action buttons (without authentication)
        if helper.browser.element_exists(".add-to-cart").await {
            log::info!("Add to cart button available on product details");
        }
        
        if helper.browser.element_exists(".buy-now").await {
            log::info!("Buy now button available on product details");
        }
    }

    log::info!("Product details pages test completed successfully");
    Ok(())
}

/// Test marketplace accessibility and responsiveness
#[tokio::test]
#[serial_test::serial]
async fn test_marketplace_accessibility() -> Result<(), Box<dyn std::error::Error>> {
    let environment = TestFixtures::setup_test_environment().await?;
    let mut helper = UXTestHelper::new(&environment);

    log::info!("Testing marketplace accessibility and responsiveness");

    // Navigate to marketplace
    helper.browser.navigate_to("/marketplace").await?;
    
    // Test different viewport sizes
    let viewport_sizes = vec![
        (1920, 1080), // Desktop
        (768, 1024),  // Tablet
        (375, 667),   // Mobile
    ];
    
    for (width, height) in viewport_sizes {
        log::info!("Testing viewport size: {}x{}", width, height);
        
        // Set viewport size
        helper.browser.driver.set_window_size(width, height).await?;
        
        // Wait for layout to adjust
        helper.wait(std::time::Duration::from_millis(500)).await;
        
        // Take screenshot for visual verification
        helper.take_screenshot(&format!("marketplace_{}x{}", width, height)).await?;
        
        // Verify key elements are still accessible
        assert!(helper.browser.element_exists("body").await);
    }
    
    // Reset to default size
    helper.browser.driver.set_window_size(1920, 1080).await?;

    log::info!("Marketplace accessibility test completed successfully");
    Ok(())
}