################################################################################
# Ferrum Installation and Basic Usage
# Install the Ferrum gem
# gem install ferrum
# Ensure you have Google Chrome or Chromium installed on your system.
################################################################################
require 'ferrum'

# Initialize Ferrum browser in headless mode (default) or headful for debugging
browser = Ferrum::Browser.new(headless: true)

# Navigate to a URL
browser.go_to('https://www.google.com')

# Get the title of the page
puts "Ferrum Page Title: #{browser.title}"

# Take a screenshot
browser.screenshot(path: 'ferrum_google.png')

# Close the browser
browser.quit
puts "Ferrum: Visited Google and took a screenshot."


################################################################################
# Selenium WebDriver Installation and Basic Usage
# Install the Selenium WebDriver gem
# gem install selenium-webdriver
# Download ChromeDriver: https://sites.google.com/chromium.org/driver/
# Ensure chromedriver is in your PATH or specify its location.
################################################################################
require 'selenium-webdriver'

# Configure Chrome options for headless mode
options = Selenium::WebDriver::Chrome::Options.new
options.add_argument('--headless') # Run Chrome in headless mode
options.add_argument('--disable-gpu') # Required for headless on some systems

# Initialize Selenium WebDriver
driver = Selenium::WebDriver.for :chrome, options: options

# Navigate to a URL
driver.navigate.to 'https://www.bing.com'

# Get the title of the page
puts "Selenium Page Title: #{driver.title}"

# Take a screenshot
driver.save_screenshot('selenium_bing.png')

# Close the browser
driver.quit
puts "Selenium: Visited Bing and took a screenshot."

################################################################################
# Ferrum: Basic Interactions for Web Scraping and Automation
# This script demonstrates navigation, element finding, text input, and clicking.
################################################################################
require 'ferrum'

# Initialize browser with a custom user agent (good practice for scraping)
browser = Ferrum::Browser.new(headless: true, user_agent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')

begin
  # Navigate to a target URL
  puts "Navigating to example.com..."
  browser.go_to('https://www.example.com/login') # Assuming a login page exists for demonstration
  sleep 1 # Allow page to load

  # Find elements by CSS selector and fill them
  puts "Finding and filling login form..."
  # Note: Replace 'input#username' and 'input#password' with actual selectors
  # of the target website's login form.
  username_field = browser.at_css('input#username') # Example: find an input with id='username'
  password_field = browser.at_css('input#password') # Example: find an input with id='password'

  if username_field && password_field
    username_field.fill('testuser')
    password_field.fill('password123')
    puts "Form fields filled."

    # Find and click the submit button
    # Note: Replace 'button#submit-button' with the actual selector of the submit button.
    submit_button = browser.at_css('button#submit-button')
    if submit_button
      submit_button.click
      puts "Submit button clicked."
      sleep 2 # Wait for navigation/action to complete
    else
      puts "Error: Submit button not found. Please check selector."
    end
  else
    puts "Error: Username or password fields not found. Please check selectors."
  end

  # Verify navigation or content after login (example: check for a 'Welcome' message)
  # Use a robust selector with an explicit wait
  # logged_in_element = browser.at_css('div.welcome-message', wait: 5)
  # if logged_in_element
  #   puts "Successfully logged in! Welcome message: #{logged_in_element.text}"
  # else
  #   puts "Login verification failed: Welcome message not found."
  # end

  # Take a screenshot to verify the final state
  browser.screenshot(path: 'ferrum_login_success.png')
  puts "Screenshot 'ferrum_login_success.png' captured."

  # Extract data from the page after interaction
  # Example: Extract all link texts
  # links = browser.css('a').map(&:text)
  # puts "Extracted links: #{links.join(', ')}"

rescue Ferrum::Error => e
  puts "A Ferrum error occurred: #{e.message}"
  browser.screenshot(path: 'ferrum_error_state.png') if browser # Capture state on error
rescue => e
  puts "An unexpected error occurred: #{e.class} - #{e.message}"
  browser.screenshot(path: 'ferrum_unexpected_error.png') if browser # Capture state on error
ensure
  # Always close the browser to release resources
  browser.quit if browser && browser.connected?
  puts "Browser closed."
end

################################################################################
# Selenium: Advanced Interactions for Complex Web Automation
# This script demonstrates handling dynamic content, iframes, and window switching.
################################################################################
require 'selenium-webdriver'

# Configure Chrome options for headless mode and custom user agent
options = Selenium::WebDriver::Chrome::Options.new
options.add_argument('--headless')
options.add_argument('--disable-gpu')
options.add_argument('--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36')

driver = nil # Initialize driver to nil for ensure block safety

begin
  driver = Selenium::WebDriver.for :chrome, options: options
  driver.manage.window.maximize # Maximize window for consistent element visibility

  # Scenario 1: Handling Dynamic Content with Explicit Waits
  puts "Navigating to a dynamic content page..."
  driver.navigate.to 'https://the-internet.herokuapp.com/dynamic_loading/1' # Example of dynamic loading

  start_button = driver.find_element(css: '#start button')
  start_button.click

  # Use an explicit wait to wait for the element to become visible
  wait = Selenium::WebDriver::Wait.new(timeout: 10) # Wait up to 10 seconds
  finish_message = wait.until { driver.find_element(id: 'finish') }
  puts "Dynamic content loaded: #{finish_message.text}"

  # Scenario 2: Interacting with Iframes
  puts "\nNavigating to an iframe example..."
  driver.navigate.to 'https://the-internet.herokuapp.com/iframe'

  # Switch to the iframe by ID or name
  # Note: The iframe ID is 'mce_0_ifr' on this specific page
  driver.switch_to.frame('mce_0_ifr')
  puts "Switched to iframe."

  # Interact with elements inside the iframe
  text_editor = driver.find_element(id: 'tinymce')
  text_editor.clear
  text_editor.send_keys('Hello from inside the iframe with Selenium!')
  puts "Text entered in iframe editor."

  # Switch back to the default content (main page)
  driver.switch_to.default_content
  puts "Switched back to default content."

  # Scenario 3: Managing Multiple Windows/Tabs
  puts "\nNavigating to a new window example..."
  driver.navigate.to 'https://the-internet.herokuapp.com/windows'

  # Click to open a new window
  driver.find_element(css: '.example a').click

  # Get all window handles
  window_handles = driver.window_handles
  original_window = window_handles[0]
  new_window = window_handles[1]

  # Switch to the new window
  driver.switch_to.window(new_window)
  puts "Switched to new window. New window title: #{driver.title}"
  puts "Text from new window: #{driver.find_element(css: 'h3').text}"

  # Close the new window
  driver.close
  puts "New window closed."

  # Switch back to the original window
  driver.switch_to.window(original_window)
  puts "Switched back to original window. Original window title: #{driver.title}"

  # Take a final screenshot of the original window
  driver.save_screenshot('selenium_advanced_scenarios.png')
  puts "Screenshot 'selenium_advanced_scenarios.png' captured."

rescue Selenium::WebDriver::Error::NoSuchElementError => e
  puts "Error: Element not found. #{e.message}"
  driver.save_screenshot('selenium_error_no_such_element.png') if driver
rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
  puts "Error: Stale element reference. #{e.message}"
  driver.save_screenshot('selenium_error_stale_element.png') if driver
rescue Selenium::WebDriver::Error::WebDriverError => e
  puts "A Selenium WebDriver error occurred: #{e.message}"
  driver.save_screenshot('selenium_error_webdriver.png') if driver
rescue => e
  puts "An unexpected error occurred: #{e.class} - #{e.message}"
  driver.save_screenshot('selenium_error_unexpected.png') if driver
ensure
  driver.quit if driver && driver.connected? # Ensure browser is closed
  puts "Browser closed after advanced scenarios."
end

################################################################################
# Robust Element Selection and Error Handling
# This example focuses on making element interactions more resilient.
################################################################################
require 'selenium-webdriver'

options = Selenium::WebDriver::Chrome::Options.new
options.add_argument('--headless')
options.add_argument('--disable-gpu')

driver = nil

begin
  driver = Selenium::WebDriver.for :chrome, options: options
  driver.manage.window.maximize

  driver.navigate.to('https://www.example.com') # Replace with your target URL for testing
  puts "Navigated to example.com"

  # Good Practice 1: Use robust selectors (ID is best, then unique class/data attributes)
  # Instead of: driver.find_element(css: 'div.some-class p a')
  # Prefer: driver.find_element(id: 'unique-button-id')
  # Or with a custom data attribute: driver.find_element(css: '[data-test-id="action-button"]')

  # Simulate finding a button that might or might not be present, or might take time to load
  wait = Selenium::WebDriver::Wait.new(timeout: 15) # Increased timeout for robustness

  # Attempt to find an element using a CSS selector (e.g., a button with specific text)
  # We use a block with until for more flexible conditions
  element_to_click = wait.until do
    driver.find_elements(css: 'button').find { |btn| btn.text == 'Click Me' && btn.displayed? }
  end

  if element_to_click
    puts "Found 'Click Me' button. Clicking it..."
    element_to_click.click
    sleep 2 # Short pause after click
    puts "Clicked 'Click Me' button."
  else
    puts "'Click Me' button not found after waiting."
  end

  # Good Practice 2: Comprehensive Error Handling
  # Attempt an action that might fail (e.g., finding a non-existent element)
  begin
    non_existent_element = driver.find_element(id: 'non-existent-id-123')
    non_existent_element.click # This line won't be reached if element is not found
  rescue Selenium::WebDriver::Error::NoSuchElementError => e
    puts "Caught expected error: Element 'non-existent-id-123' not found. Message: #{e.message}"
    # Log the error, take a screenshot, or perform recovery actions
    driver.save_screenshot('error_non_existent_element.png')
  rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
    puts "Caught Stale Element Reference Error. Retrying or refreshing..."
    # Implement retry logic or page refresh here
    driver.navigate.refresh
    # Then try to find the element again
  end

  # Good Practice 3: Resource Management - ensuring browser closure
  # (Demonstrated in the ensure block below)

  # Good Practice 4: Rate Limiting for Data Extraction
  # For scraping, implement delays to avoid overwhelming servers or getting blocked.
  # sleep(rand(2..5)) # Random delay between 2 and 5 seconds after each request/interaction

  puts "Script completed successfully with robust practices."

rescue Selenium::WebDriver::Error::WebDriverError => e
  puts "A Selenium WebDriver error occurred: #{e.message}"
  driver.save_screenshot('error_general_webdriver.png') if driver
rescue => e
  puts "An unexpected error occurred: #{e.class} - #{e.message}"
  driver.save_screenshot('error_unexpected_script.png') if driver
ensure
  driver.quit if driver && driver.connected? # Always ensure the browser is closed
  puts "Browser session terminated."
end