import requests
from bs4 import BeautifulSoup # Required if parsing page for hidden fields or CSRF tokens

# --- Step 1: Define Target URL and Form Data ---
# This is a hypothetical URL and form structure.
# In a real scenario, you'd inspect the actual website's form using browser developer tools.
# Look for the <form action="..."> and <input name="..."> attributes.

FORM_ACTION_URL = 'http://example.com/login' # Replace with the actual form submission URL

# Define the data payload as a dictionary.
# Keys are the 'name' attributes of the form input fields.
# Values are the data you want to submit.
form_data = {
    'username': 'your_username',
    'password': 'your_password',
    'submit_button': 'Login' # Often, a submit button also has a 'name' and 'value'
}

# --- Optional: Step 2: Fetch the page to extract dynamic data (e.g., CSRF token) ---
# Uncomment and adapt this section if your form has dynamic hidden fields or CSRF tokens.
# response_get = requests.get(FORM_ACTION_URL)
# soup = BeautifulSoup(response_get.text, 'html.parser')
#
# # Example: Find a hidden CSRF token
# csrf_token_input = soup.find('input', {'name': 'csrf_token'})
# if csrf_token_input:
#     form_data['csrf_token'] = csrf_token_input.get('value')
# else:
#     print("CSRF token not found. Proceeding without it.")

# --- Step 3: Set Custom Headers (Good Practice) ---
# Impersonate a browser to avoid detection.
headers = {
    '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',
    'Referer': 'http://example.com/login', # Referer header
    'Content-Type': 'application/x-www-form-urlencoded' # Standard for form submissions
}

# --- Step 4: Submit the Form using a POST Request ---
try:
    response_post = requests.post(FORM_ACTION_URL, data=form_data, headers=headers, timeout=10) # 10-second timeout

    # --- Step 5: Analyze the Response ---
    if response_post.status_code == 200:
        print("Form submitted successfully!")
        print(f"Final URL: {response_post.url}")
        # print("Response content (first 500 chars):")
        # print(response_post.text[:500])
        
        # We can further parse the response HTML to check for success messages,
        # redirection, or errors.
        if "Login Successful" in response_post.text: # Hypothetical success message
            print("Login confirmed in response content.")
        elif "Invalid Credentials" in response_post.text:
            print("Login failed: Invalid credentials.")
        else:
            print("Response content review needed to determine outcome.")
            
    elif response_post.status_code == 302: # Often indicates a redirect after successful login
        print(f"Form submitted. Redirected to: {response_post.headers['Location']}")
    else:
        print(f"Form submission failed with status code: {response_post.status_code}")
        print("Response content:")
        print(response_post.text[:500]) # Print first 500 characters of response for debugging

except requests.exceptions.RequestException as e:
    print(f"An error occurred during the request: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.service import Service as ChromeService
from webdriver_manager.chrome import ChromeDriverManager
import time

# --- Step 1: Initialize WebDriver ---
# For Chrome, using webdriver_manager to automatically handle driver downloads.
# Ensure you have Chrome installed.

# To run in headless mode (without opening a browser window):
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument("--headless") # Uncomment to run in headless mode
chrome_options.add_argument("--no-sandbox") # Recommended for headless on Linux
chrome_options.add_argument("--disable-dev-shm-usage") # Recommended for headless on Linux
chrome_options.add_argument(
    "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"
) # Set a custom User-Agent

try:
    # Initialize the WebDriver service using ChromeDriverManager
    service = ChromeService(ChromeDriverManager().install())
    driver = webdriver.Chrome(service=service, options=chrome_options)

    # Set an implicit wait (optional, but good for general element loading)
    driver.implicitly_wait(10) # Wait up to 10 seconds for elements to appear

    # --- Step 2: Navigate to the Target URL ---
    TARGET_URL = 'http://example.com/dynamic_form' # Replace with your target dynamic form URL
    print(f"Navigating to {TARGET_URL}...")
    driver.get(TARGET_URL)

    # --- Step 3: Wait for Elements to be Present/Interactable (Explicit Wait is Key) ---
    # Define a WebDriverWait instance with a timeout.
    wait = WebDriverWait(driver, 20) # Wait up to 20 seconds for specific conditions

    # Hypothetical form fields:
    # Look for element IDs, names, CSS selectors, or XPaths using browser developer tools.
    # For example: <input type="text" id="firstNameField">
    # <input type="email" name="userEmail">
    # <button type="submit" class="submit-btn">
    
    # Wait for the first name input field to be visible and enabled
    print("Waiting for 'firstName' field...")
    first_name_field = wait.until(EC.visibility_of_element_located((By.ID, 'firstNameField')))
    
    # Wait for the email input field
    print("Waiting for 'userEmail' field...")
    email_field = wait.until(EC.presence_of_element_located((By.NAME, 'userEmail')))

    # Wait for the submit button to be clickable
    print("Waiting for 'submit-btn'...")
    submit_button = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'submit-btn')))

    # --- Step 4: Fill the Form Fields ---
    print("Filling form fields...")
    first_name_field.send_keys("John")
    email_field.send_keys("john.doe@example.com")

    # Add a short pause if needed for client-side validations to trigger (optional)
    time.sleep(1) 

    # --- Step 5: Submit the Form ---
    print("Submitting the form...")
    submit_button.click()

    # --- Step 6: Verify Submission or Wait for Redirection ---
    # After submission, the page might redirect or show a success message.
    # Wait for a specific element on the success page, or for the URL to change.
    
    print("Waiting for post-submission page or redirect...")
    # Example: Wait for the URL to contain a specific success path
    wait.until(EC.url_contains('/success')) 
    
    print(f"Form submitted successfully! Current URL: {driver.current_url}")
    print("Page title after submission:", driver.title)
    
    # You can also check for success messages in the page source
    # if "Submission Confirmed" in driver.page_source:
    #     print("Success message found in page content.")

except Exception as e:
    print(f"An error occurred: {e}")
finally:
    # --- Step 7: Close the Browser ---
    if 'driver' in locals() and driver:
        print("Closing browser...")
        driver.quit()

import requests
import time
import random

# --- Step 1: Implement Robust Error Handling (with requests example) ---
def submit_form_robustly(url, data, headers, max_retries=3):
    """
    Submits a form with retry logic for common transient errors.
    """
    for attempt in range(max_retries):
        try:
            print(f"Attempt {attempt + 1} to submit form to {url}...")
            response = requests.post(url, data=data, headers=headers, timeout=15)
            response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
            print("Form submitted successfully!")
            return response
        except requests.exceptions.HTTPError as http_err:
            print(f"HTTP error occurred: {http_err} on attempt {attempt + 1}")
        except requests.exceptions.ConnectionError as conn_err:
            print(f"Connection error occurred: {conn_err} on attempt {attempt + 1}")
        except requests.exceptions.Timeout as timeout_err:
            print(f"Timeout error occurred: {timeout_err} on attempt {attempt + 1}")
        except requests.exceptions.RequestException as req_err:
            print(f"An unexpected request error occurred: {req_err} on attempt {attempt + 1}")
        
        # Implement exponential backoff or simple delay before retrying
        if attempt < max_retries - 1:
            sleep_time = 2 ** attempt + random.uniform(0, 1) # Exponential backoff + jitter
            print(f"Retrying in {sleep_time:.2f} seconds...")
            time.sleep(sleep_time)
            
    print(f"Failed to submit form after {max_retries} attempts.")
    return None

# Hypothetical form data and URL for testing error handling
TEST_URL = 'http://httpbin.org/post' # A public endpoint for testing POST requests
TEST_DATA = {'key': 'value', 'another_key': 'another_value'}
TEST_HEADERS = {
    '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',
    'Content-Type': 'application/x-www-form-urlencoded'
}

# Example usage of robust submission
# response = submit_form_robustly(TEST_URL, TEST_DATA, TEST_HEADERS)
# if response:
#     print("Final response status:", response.status_code)
#     print("Response JSON:", response.json()) # httpbin.org returns JSON

# --- Step 2: Implement Rate Limiting ---
def process_multiple_submissions(urls_and_data, delay_seconds=5):
    """
    Processes a list of form submissions with a delay between each to avoid rate limits.
    """
    for i, (url, data, headers) in enumerate(urls_and_data):
        print(f"\nProcessing submission {i + 1}...")
        response = submit_form_robustly(url, data, headers)
        if response:
            print(f"Submission {i + 1} successful.")
        else:
            print(f"Submission {i + 1} failed.")
            
        if i < len(urls_and_data) - 1:
            print(f"Waiting {delay_seconds} seconds before next submission...")
            time.sleep(delay_seconds + random.uniform(0, 2)) # Add jitter

# Example list of submissions (each tuple: url, data, headers)
# multiple_submissions_list = [
#     (TEST_URL, {'item1': 'data1'}, TEST_HEADERS),
#     (TEST_URL, {'item2': 'data2'}, TEST_HEADERS),
#     (TEST_URL, {'item3': 'data3'}, TEST_HEADERS)
# ]
# process_multiple_submissions(multiple_submissions_list, delay_seconds=3)

# --- Step 3: Setting Custom User-Agent (for requests) ---
# Already included in TEST_HEADERS above, but explicitly demonstrating.
custom_user_agent_headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36',
    'Accept-Language': 'en-US,en;q=0.9',
    'Accept-Encoding': 'gzip, deflate, br',
    'Connection': 'keep-alive',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9'
}

# You can pass this to requests.post() or requests.get()
# response = requests.post(TEST_URL, data=TEST_DATA, headers=custom_user_agent_headers)
# print(f"\nUser-Agent submission status: {response.status_code}")