import utils  # 🎉 Auto-enables ARIA methods on WebDriver!

# Natural element location (just like native Selenium)
username = driver.find_element_by_role("textbox", name="Username")
submit_btn = driver.find_element_by_role("button", name="Submit")
all_links = driver.find_elements_by_role("link")

from utils import ARIARole, LocatorConfig

# Use enums for IDE support and safety
email_field = driver.find_element_by_role(ARIARole.TEXTBOX, name="Email")
login_button = driver.find_element_by_role(ARIARole.BUTTON, name="Login")

# Configure advanced options
config = LocatorConfig(
    bidi_priority=True,        # Prefer BiDi when available
    cdp_fallback=True,         # Enable CDP fallback
    debug_mode=True           # Detailed logging
)

from utils.bidi_locators import BiDiAccessibilityLocator

# Direct BiDi usage
locator = BiDiAccessibilityLocator(driver)

# Check BiDi availability
if locator.is_available():
    elements = locator.find_elements(
        role="button",
        name="Submit",
        max_count=10
    )

# Enable BiDi in your WebDriver
chrome_options.set_capability("webSocketUrl", True)  # Essential!
firefox_options.set_capability("webSocketUrl", True)
edge_options.set_capability("webSocketUrl", True)

class BiDiAccessibilityLocator:
    def _execute_bidi_command(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
        execution_strategies = [
            self._try_native_browsing_context,    # Selenium 4.15+
            self._try_direct_bidi_command,        # Future versions
            self._try_legacy_bidi_connection,     # Legacy support
            self._try_cdp_bridge                  # CDP fallback
        ]
        
        for strategy in execution_strategies:
            try:
                result = strategy(method, params)
                if result is not None:
                    return result
            except Exception as e:
                logger.debug(f"Strategy failed: {strategy.__name__}: {e}")
                continue

class BiDiAccessibilityLocator:
    def __init__(self, driver: WebDriver) -> None:
        self.driver = driver
        self._context_id: Optional[str] = None          # Cache context ID
        self._bidi_available: Optional[bool] = None     # Cache availability

# Exception chaining for better debugging
except WebDriverException as e:
    raise BiDiNotAvailableError(f"Context error: {e}") from e

class TestBiDiIntegration:
    def test_bidi_availability_check(self, driver):
        """Verify BiDi detection works correctly"""
        
    def test_bidi_direct_usage_when_available(self, driver):
        """Test direct BiDi implementation"""
        
    def test_priority_order_works(self, driver):
        """Verify BiDi → CDP → DOM cascade"""
        
    def test_error_handling(self, driver):
        """Test robust error scenarios"""

from utils import LocatorConfig

config = LocatorConfig(debug_mode=True)

def test_performance_comparison(self, driver):
    """Compare BiDi vs CDP vs DOM performance"""
    
    # Measure execution times
    bidi_time = measure_execution_time(bidi_locator.find_elements)
    cdp_time = measure_execution_time(cdp_locator.find_elements) 
    dom_time = measure_execution_time(dom_locator.find_elements)

from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.set_capability("webSocketUrl", True)  # Enable BiDi
chrome_options.add_argument("--headless")            # Optional
chrome_options.add_argument("--no-sandbox")          # CI/CD
chrome_options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=chrome_options)

from selenium.webdriver.firefox.options import Options

firefox_options = Options() 
firefox_options.set_capability("webSocketUrl", True)  # Enable BiDi
firefox_options.add_argument("--headless")            # Optional

driver = webdriver.Firefox(options=firefox_options)

from selenium.webdriver.edge.options import Options

edge_options = Options()
edge_options.set_capability("webSocketUrl", True)     # Enable BiDi
edge_options.add_argument("--headless")               # Optional

driver = webdriver.Edge(options=edge_options)

from utils import LocatorConfig

# Advanced configuration
config = LocatorConfig(
    bidi_priority=True,           # Prefer BiDi when available
    cdp_fallback=True,           # Enable CDP fallback
    dom_fallback=True,           # Enable DOM fallback  
    debug_mode=True,             # Detailed logging
    timeout=10,                  # Element timeout (seconds)
    retry_count=3,               # Retry attempts
    cache_results=True           # Cache element lookups
)

# Apply configuration globally
driver.aria_config = config

from utils.bidi_locators import BiDiAccessibilityLocator

# Direct BiDi usage (advanced)
bidi_locator = BiDiAccessibilityLocator(driver)

if bidi_locator.is_available():
    # Find with custom parameters
    elements = bidi_locator.find_elements(
        role="button",
        name="Submit", 
        max_count=5,                    # Limit results
        pressed=False,                  # Button state
        disabled=False                  # Accessibility state
    )
    
    # Single element with validation
    try:
        submit_btn = bidi_locator.find_element("button", name="Submit")
    except NoSuchElementException:
        print("Submit button not found")

import time
from utils import LocatorConfig

# Performance testing
config = LocatorConfig(debug_mode=True)

start_time = time.time()
elements = driver.find_elements_by_role("button")
execution_time = time.time() - start_time

print(f"Found {len(elements)} elements in {execution_time:.3f}s")

from utils.bidi_locators import BiDiNotAvailableError
from selenium.common.exceptions import NoSuchElementException

try:
    # Attempt element location
    element = driver.find_element_by_role("button", name="Submit")
    element.click()
    
except BiDiNotAvailableError:
    # BiDi not available, but fallback should work
    print("BiDi unavailable, using fallback methods")
    
except NoSuchElementException:
    # Element genuinely not found
    print("Submit button not found on page")
    
except Exception as e:
    # Unexpected error
    print(f"Unexpected error: {e}")