import requests
from bs4 import BeautifulSoup
import re

# Hardcoded scraping - breaks when HTML changes
def check_ebay_kleinanzeigen():
    response = requests.get("https://www.kleinanzeigen.de/s-musik/berlin/op-1/k0c74l3331")
    soup = BeautifulSoup(response.content, 'html.parser')
    
    # Brittle CSS selectors
    listings = soup.find_all('div', class_='aditem-main')
    
    for listing in listings:
        price_elem = listing.find('strong', class_='aditem-main--middle--price-shipping--price')
        # More brittle parsing...
        if price_elem and '€' in price_elem.text:
            price = int(re.search(r'(\d+)', price_elem.text).group(1))
            if price < 500:
                # Still need to manually check description quality...
                return listing

from strands import Agent
from strands.models.bedrock import BedrockModel

# Natural language instructions
agent = Agent(
    model=BedrockModel(model_id="eu.anthropic.claude-3-7-sonnet-20250219-v1:0"),
    system_prompt="""
    Find Teenage Engineering OP-1 synthesizers on eBay Kleinanzeigen:
    - Price under €500
    - Good condition, no issues mentioned
    - Located within 50km of Berlin
    - Send notification if found
    """,
    tools=[browse_website, send_notification]
)

# Agent figures out how to search, evaluate, and notify
result = agent("Check for OP-1 deals on eBay Kleinanzeigen")

from strands.tools import tool
import requests
from bs4 import BeautifulSoup

@tool
def browse_website(url: str) -> str:
    """Browse a website and return its text content.
    
    Args:
        url: The URL to browse
        
    Returns:
        The cleaned text content of the website
    """
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    response = requests.get(url, headers=headers, timeout=10)
    response.raise_for_status()
    
    soup = BeautifulSoup(response.content, 'html.parser')
    
    # Remove script and style elements
    for script in soup(["script", "style"]):
        script.decompose()
    
    # Get clean text
    text = soup.get_text()
    lines = (line.strip() for line in text.splitlines())
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    text = ' '.join(chunk for chunk in chunks if chunk)
    
    # Limit length to avoid overwhelming the model
    return text[:8000] if len(text) > 8000 else text

@tool
def send_notification(message: str) -> str:
    """Send a notification message.
    
    Args:
        message: The message to send
        
    Returns:
        Success confirmation
    """
    import json
    import boto3
    
    # Get Telegram credentials from AWS Secrets Manager
    secrets_client = boto3.client('secretsmanager')
    secret = secrets_client.get_secret_value(SecretId='op1-finder-secrets')
    credentials = json.loads(secret['SecretString'])
    
    # Send via Telegram (simplified)
    telegram_url = f"https://api.telegram.org/bot{credentials['TELEGRAM_TOKEN']}/sendMessage"
    payload = {
        'chat_id': credentials['TELEGRAM_CHAT_ID'],
        'text': message,
        'parse_mode': 'Markdown'
    }
    
    response = requests.post(telegram_url, json=payload)
    response.raise_for_status()
    
    return "Notification sent successfully"

from strands import Agent
from strands.models.bedrock import BedrockModel

# Create the AI model
model = BedrockModel(
    model_id="eu.anthropic.claude-3-7-sonnet-20250219-v1:0",
    region="eu-west-1"
)

# System prompt with clear instructions
SYSTEM_PROMPT = """
You are an OP-1 synthesizer hunting agent for eBay Kleinanzeigen.

TASK: Find Teenage Engineering OP-1 synthesizers that meet these criteria:
- Price under €500
- Condition described as "good", "very good", "excellent", or "like new"
- NO issues, defects, or problems mentioned in description
- Located within 50km of Berlin (PLZ 10000-14999 or nearby cities like Potsdam, Brandenburg)
- Currently available (not marked as sold/reserved)

PROCESS:
1. Browse https://www.ebay-kleinanzeigen.de/s-musik/berlin/teenage+engineering+op-1/k0c74l3331
2. For each listing that seems promising:
   - Check the individual listing page for full details
   - Evaluate against all criteria carefully
   - If it matches, send notification with:
     * Title and brief description
     * Price and condition
     * Location
     * Direct link to listing
     * Reason why it matches criteria

Be thorough but only notify for genuine matches to avoid spam. Check not more than 5 listings.

IMPORTANT: Be verbose about your process. Log what you're doing:
- "Browsing search results page..."
- "Found X listings, checking each one..."
- "Checking listing: {title}..."
- "This listing matches/doesn't match because..."

TOOLS AVAILABLE:
- browse_website (web browsing)
- send_notification (alert when good deal found)
"""

# Create the agent
agent = Agent(
    model=model,
    system_prompt=SYSTEM_PROMPT,
    tools=[browse_website, send_notification]
)

import json
import logging
import boto3
from strands import Agent
from strands.models.bedrock import BedrockModel

# Set up logging
logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)

# ... (tool definitions from above) ...

def lambda_handler(event, context):
    """AWS Lambda handler for OP-1 finder agent."""
    
    log.info("🎹 Starting OP-1 finder agent...")
    
    try:
        # Create agent (same as Step 3)
        model = BedrockModel(model_id="eu.anthropic.claude-3-7-sonnet-20250219-v1:0")
        agent = Agent(
            model=model,
            system_prompt=SYSTEM_PROMPT,
            tools=[browse_website, send_notification]
        )
        
        # Run the agent
        result = agent("Check eBay Kleinanzeigen for OP-1 synthesizers matching my criteria")
        
        log.info(f"✅ Agent completed: {result}")
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': 'OP-1 search completed successfully',
                'result': str(result)
            })
        }
        
    except Exception as e:
        log.error(f"❌ Error running agent: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }