# Part 1 Code: A foundational web automation script (Selenium)
# Ensure you have 'selenium' installed: pip install selenium
# And a WebDriver (e.g., ChromeDriver) compatible with your Chrome version
# Download ChromeDriver from: https://chromedriver.chromium.org/downloads
# Place it in your system PATH or specify its executable_path.

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
import os

def run_basic_web_automation():
    """Simulates a basic web automation task: navigating to python.org and printing the title."""
    # Configure Chrome options to run headless (without a visible browser UI)
    chrome_options = Options()
    chrome_options.add_argument("--headless") # Crucial for server environments
    chrome_options.add_argument("--no-sandbox") # Required for some Linux environments
    chrome_options.add_argument("--disable-dev-shm-usage") # Overcomes limited resource issues in Docker/CI
    
    # Example of specifying WebDriver path (uncomment and adjust if not in PATH)
    # chromedriver_path = "/usr/local/bin/chromedriver" # Adjust this path
    # service = Service(executable_path=chromedriver_path)
    
    driver = None # Initialize driver outside try block
    try:
        # If using `service`, pass it: driver = webdriver.Chrome(service=service, options=chrome_options)
        driver = webdriver.Chrome(options=chrome_options) 
        driver.get("https://www.python.org")
        print(f"Successfully accessed {driver.current_url}")
        print(f"Page title: {driver.title}")
        # In a real scenario, we would add scraping, interaction, or testing logic here.
    except Exception as e:
        print(f"Error during web automation: {e}")
        # Implement robust error logging and handling for production systems
    finally:
        if driver:
            driver.quit() # Always close the browser to free up resources

if __name__ == "__main__":
    print("Executing a basic web automation task to demonstrate scheduled potential...")
    run_basic_web_automation()
    print("Basic web automation task completed. Imagine this running automatically!")

# Part 2 Code: A simple Python script designed for OS-level scheduling
# Save this as `my_scheduled_script.py`
import datetime
import sys
import os

def main():
    """Logs the current timestamp and any provided arguments to a file."""
    # Define the log file path
    log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'logs')
    os.makedirs(log_dir, exist_ok=True) # Ensure log directory exists
    log_file_path = os.path.join(log_dir, "scheduled_output.log")

    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_message = f"Script executed at: {timestamp}"
    
    # Capture and log any command-line arguments
    if len(sys.argv) > 1:
        args = " ".join(sys.argv[1:])
        log_message += f" | Arguments: {args}"

    try:
        with open(log_file_path, "a") as f:
            f.write(log_message + "\n")
        print(f"[SUCCESS] Logged execution at {timestamp} to {log_file_path}")
    except Exception as e:
        print(f"[ERROR] Failed to write to log file: {e}")
        sys.exit(1) # Indicate failure to the scheduler

if __name__ == "__main__":
    main()


# --- Example Cron Entry (Linux/macOS) ---
# To edit your crontab, run `crontab -e` in your terminal.
# Add the following line to run `my_scheduled_script.py` every hour at minute 0:
# 0 * * * * /usr/bin/python3 /path/to/my_scheduled_script.py 'HourlyRun' >> /path/to/logs/cron_output.log 2>&1
# Explanation:
# 0 * * * *          ->  Run at minute 0 past every hour
# /usr/bin/python3   ->  Full path to your Python interpreter (check with `which python3`)
# /path/to/my_scheduled_script.py -> Full path to your Python script
# 'HourlyRun'        ->  An example argument passed to the script
# >> /path/to/logs/cron_output.log 2>&1 -> Redirect stdout and stderr to a log file


# --- Example Task Scheduler Command (Windows) ---
# Open Command Prompt or PowerShell as Administrator.
# Create a basic task to run daily at 9:00 AM:
# SCHTASKS /CREATE /TN "MyPythonAutomationTask" /TR "cmd.exe /c "C:\Python\Python39\python.exe C:\path\to\my_scheduled_script.py DailyRun > C:\path\to\logs\task_output.log 2>&1"" /SC DAILY /ST 09:00:00
# Explanation:
# /TN "MyPythonAutomationTask" -> Task Name
# /TR "..."                      -> Command to run (cmd.exe /c is crucial for redirection)
# "C:\Python\Python39\python.exe" -> Full path to your Python interpreter
# "C:\path\to\my_scheduled_script.py" -> Full path to your Python script
# "DailyRun"                     -> An example argument passed to the script
# " > C:\path\to\logs\task_output.log 2>&1" -> Redirect stdout/stderr to a log file
# /SC DAILY /ST 09:00:00           -> Schedule: daily, starting at 9 AM

# Part 3 Code: Demonstrating the 'schedule' library for in-process scheduling
# Install the schedule library: pip install schedule

import schedule
import time
import datetime
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
import os

def perform_web_scrape(target_url="https://www.python.org/downloads/"):
    """Performs a simulated web scrape, logging status and (potentially) data."""
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_message_prefix = f"[{timestamp}] Web Scrape:"
    
    chrome_options = Options()
    chrome_options.add_argument("--headless")
    chrome_options.add_argument("--no-sandbox")
    chrome_options.add_argument("--disable-dev-shm-usage")

    driver = None
    try:
        print(f"{log_message_prefix} Initiating scrape of {target_url}...")
        driver = webdriver.Chrome(options=chrome_options)
        driver.get(target_url)
        page_title = driver.title
        # Simulate data extraction (e.g., finding the latest Python version)
        latest_version_element = driver.find_element(
            webdriver.common.by.By.CSS_SELECTOR, 
            '.download-for-windows > p:nth-child(1) > a:nth-child(1)'
        )
        latest_version_text = latest_version_element.text if latest_version_element else "N/A"
        
        log_status = f"SUCCESS - Title: '{page_title}', Latest Python: '{latest_version_text}'"
        print(f"{log_message_prefix} {log_status}")
        # In a real scenario, save data to DB, CSV, etc.

    except Exception as e:
        log_status = f"FAILURE - Error: {e}"
        print(f"{log_message_prefix} {log_status}")
    finally:
        if driver:
            driver.quit()

    # Log results to a file for persistent record
    with open("scheduled_web_scrape_log.txt", "a") as f:
        f.write(f"{log_message_prefix} {log_status}\n")

# Schedule tasks using the 'schedule' library
# schedule.every(10).seconds.do(perform_web_scrape) # For frequent testing
# schedule.every().minute.do(perform_web_scrape, target_url="https://www.example.com") # Every minute
schedule.every().hour.do(perform_web_scrape) # Every hour
schedule.every().day.at("09:00").do(perform_web_scrape) # Daily at 9 AM
# schedule.every().monday.at("10:00").do(perform_web_scrape) # Weekly on Monday

print("Python-native scheduler initiated. Tasks will run according to defined intervals.")
print("Press Ctrl+C to gracefully stop the scheduler.")

try:
    while True:
        schedule.run_pending() # Check and run all pending jobs
        time.sleep(1) # Wait 1 second before checking again
except KeyboardInterrupt:
    print("\nScheduler stopped by user.")
except Exception as e:
    print(f"An unexpected error occurred in the scheduler loop: {e}")

# Part 4 Code: A minimal Flask app demonstrating an API endpoint for triggering automation
# This represents a task that could be invoked by a cloud scheduler or an orchestrator.
# Install Flask: pip install Flask

from flask import Flask, request, jsonify
import threading
import time
import datetime
import subprocess # For executing external web automation script
import sys

app = Flask(__name__)

def execute_web_automation_script(task_id, script_path):
    """Executes a separate Python web automation script in a new process."""
    timestamp_start = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_prefix = f"[{timestamp_start}] Task {task_id}:"
    print(f"{log_prefix} Starting external web automation: {script_path}")
    
    try:
        # Ensure the script is executable and python interpreter path is correct
        # Using sys.executable to ensure the correct Python version is used
        # Add arguments as needed, e.g., for target URL or scrape config
        command = [sys.executable, script_path, f"--task-id={task_id}"]
        result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=300) # 5 min timeout
        
        print(f"{log_prefix} Script output:\n{result.stdout}")
        if result.stderr:
            print(f"{log_prefix} Script errors:\n{result.stderr}")
        
        print(f"{log_prefix} External web automation completed successfully.")
        return True, result.stdout + result.stderr

    except subprocess.CalledProcessError as e:
        error_output = f"Script failed with exit code {e.returncode}:\n{e.stdout}\n{e.stderr}"
        print(f"{log_prefix} ERROR: {error_output}")
        return False, error_output
    except subprocess.TimeoutExpired as e:
        error_output = f"Script timed out after {e.timeout} seconds.\n{e.stdout}\n{e.stderr}"
        print(f"{log_prefix} ERROR: {error_output}")
        return False, error_output
    except Exception as e:
        print(f"{log_prefix} An unexpected error occurred: {e}")
        return False, str(e)

@app.route('/trigger-automation', methods=['POST'])
def trigger_automation():
    data = request.get_json()
    task_id = data.get('task_id', f"auto-task-{int(time.time())}")
    # Replace with the actual path to your web automation script (e.g., the script from Part 1)
    # For this example, ensure a file named 'web_automation_script.py' exists in the same directory
    automation_script_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'web_automation_script.py')
    
    # Example of a basic web automation script for this trigger:
    # File: web_automation_script.py
    # import sys
    # import time
    # print(f"Running web automation for {sys.argv[1] if len(sys.argv) > 1 else 'generic'}")
    # time.sleep(2) # Simulate work
    # print("Web automation script finished.")

    # Run the automation task in a separate thread to not block the HTTP response.
    # For production, consider using a message queue (Celery, RabbitMQ) or a dedicated job processing system.
    thread = threading.Thread(target=execute_web_automation_script, args=(task_id, automation_script_path))
    thread.start()

    print(f"Triggered automation for task_id: {task_id}")
    return jsonify({"status": "Automation triggered", "task_id": task_id}), 202

@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({"status": "Healthy", "service": "Automation Trigger API"}), 200

if __name__ == '__main__':
    # To run this Flask app:
    # 1. Save this code as 'app.py'
    # 2. Create a dummy 'web_automation_script.py' in the same directory (see comments above).
    # 3. Run: python app.py
    # 4. In another terminal, test with curl:
    #    curl -X POST -H "Content-Type: application/json" -d '{"task_id": "daily_scrape"}' http://127.0.0.1:5000/trigger-automation
    print("Starting Flask API for automation triggers...")
    app.run(debug=True, host='0.0.0.0', port=5000) # debug=True is for development, use WSGI server for production