firstcycling.py

from typing import Any
import sys
import os
from mcp.server.fastmcp import FastMCP
import requests
from bs4 import BeautifulSoup
from typing import Dict, List, Optional, Union
from datetime import datetime
from FirstCyclingAPI.first_cycling_api.rider.rider import Rider
from FirstCyclingAPI.first_cycling_api.race.race import Race
from FirstCyclingAPI.first_cycling_api.api import FirstCyclingAPI
import re

# Add the FirstCyclingAPI directory to the Python path
sys.path.append(os.path.join(os.path.dirname(__file__), "FirstCyclingAPI"))

# Import from the FirstCycling API
from first_cycling_api.rider.rider import Rider
from first_cycling_api.race.race import RaceEdition

# Initialize FastMCP server
mcp = FastMCP("firstcycling")

@mcp.tool(
    name="get_rider_year_results",
    description="""Retrieve detailed results for a professional cyclist for a specific year.
    This tool provides comprehensive information about a rider's performance in all races during a given calendar year.
    It includes positions achieved, race categories, dates, and additional details.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get 2023 results for Tadej Pogačar (ID: 16973)
    - Get 2022 results for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Complete results for the specified year
    - Position and time for each race
    - Race category and details
    - Chronological organization by date"""
)
async def get_rider_year_results(rider_id: int, year: int) -> str:
    """Get detailed results for a professional cyclist for a specific year.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16973 for Tadej Pogačar)
        year: The year to get results for (e.g., 2023)
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get year results
        year_results = rider.year_results(year)
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(year_results, 'header_details') and year_results.header_details:
            if 'name' in year_results.header_details:
                rider_name = year_results.header_details['name']
            else:
                # Try to find name in soup
                if hasattr(year_results, 'soup') and year_results.soup:
                    name_element = year_results.soup.find('h1')
                    if name_element:
                        rider_name = name_element.text.strip()
        
        # Format title
        if rider_name:
            info += f"{year} Results for {rider_name}:\n\n"
        else:
            info += f"{year} Results for Rider ID {rider_id}:\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(year_results, 'results_df') and not (year_results.results_df is None or year_results.results_df.empty):
            # Use standard parsing
            results_df = year_results.results_df
            
            # Sort by date
            if 'Date' in results_df.columns:
                results_df = results_df.sort_values('Date')
            
            for _, row in results_df.iterrows():
                date = row.get('Date', 'N/A')
                race = row.get('Race', 'N/A')
                pos = row.get('Pos', 'N/A')
                category = row.get('CAT', 'N/A')
                
                result_line = f"{date} - {race}"
                if category and category != 'N/A':
                    result_line += f" ({category})"
                result_line += f": {pos}"
                
                info += result_line + "\n"
        else:
            # Direct HTML parsing
            if not hasattr(year_results, 'soup') or not year_results.soup:
                return f"No results found for rider ID {rider_id} in year {year}. This rider ID may not exist or the rider didn't compete this year."
            
            soup = year_results.soup
            
            # Find results table
            results_table = None
            tables = soup.find_all('table')
            
            # Look for the appropriate table that contains race results
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and any(keyword in ' '.join(headers).lower() 
                                           for keyword in ['date', 'race', 'result', 'position']):
                    results_table = table
                    break
            
            if not results_table:
                return f"No results table found for rider ID {rider_id} in year {year}. The rider may not have competed this year."
            
            # Parse results data
            rows = results_table.find_all('tr')
            if len(rows) <= 1:  # Only header row, no data
                return f"No race results found for rider ID {rider_id} in year {year}."
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data (positions may vary depending on table structure)
                date = cols[0].text.strip() if len(cols) > 0 else "N/A"
                race = cols[1].text.strip() if len(cols) > 1 else "N/A"
                pos = cols[2].text.strip() if len(cols) > 2 else "N/A"
                
                # Try to find category if available
                category = "N/A"
                for i in range(3, min(6, len(cols))):  # Check a few columns for possible category
                    col_text = cols[i].text.strip()
                    if col_text and len(col_text) <= 5 and any(c in col_text for c in [".", "WT", "1", "2"]):
                        category = col_text
                        break
                
                result_line = f"{date} - {race}"
                if category and category != 'N/A':
                    result_line += f" ({category})"
                result_line += f": {pos}"
                
                info += result_line + "\n"
        
        if not info.endswith("\n\n"):
            info += "\n"
            
        return info
    except Exception as e:
        return f"Error retrieving {year} results for rider ID {rider_id}: {str(e)}"

@mcp.tool(
    name="get_rider_victories",
    description="""Get a comprehensive list of a rider's UCI victories.
    This tool retrieves detailed information about all UCI-registered race victories achieved by the cyclist
    throughout their career. Victories can be filtered to show only WorldTour wins if desired.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get all UCI victories for Tadej Pogačar (ID: 16973)
    - Get WorldTour victories for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Complete list of victories
    - Race details including category
    - Date and year of each victory
    - Option to filter by WorldTour races only"""
)
async def get_rider_victories(rider_id: int, world_tour_only: bool = False) -> str:
    """Get a comprehensive list of a rider's UCI victories.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16973 for Tadej Pogačar)
        world_tour_only: If True, only shows WorldTour victories
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get victories (UCI victories by default)
        victories = rider.victories(world_tour=world_tour_only, uci=True)
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(victories, 'header_details') and victories.header_details:
            if 'name' in victories.header_details:
                rider_name = victories.header_details['name']
            else:
                # Try to find name in soup
                if hasattr(victories, 'soup') and victories.soup:
                    name_element = victories.soup.find('h1')
                    if name_element:
                        rider_name = name_element.text.strip()
        
        # Format title based on filter
        if rider_name:
            if world_tour_only:
                info += f"WorldTour Victories for {rider_name}:\n\n"
            else:
                info += f"UCI Victories for {rider_name}:\n\n"
        else:
            if world_tour_only:
                info += f"WorldTour Victories for Rider ID {rider_id}:\n\n"
            else:
                info += f"UCI Victories for Rider ID {rider_id}:\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(victories, 'results_df') and not (victories.results_df is None or victories.results_df.empty):
            # Use standard parsing
            results_df = victories.results_df
            
            # Group by year
            results_df = results_df.sort_values('Year', ascending=False)
            
            for year in results_df['Year'].unique():
                year_data = results_df[results_df['Year'] == year]
                info += f"{year}:\n"
                
                for _, row in year_data.iterrows():
                    date = row.get('Date', 'N/A')
                    race = row.get('Race', 'N/A')
                    category = row.get('CAT', 'N/A')
                    
                    result_line = f"  {date} - {race}"
                    if category and category != 'N/A':
                        result_line += f" ({category})"
                    
                    info += result_line + "\n"
                
                info += "\n"
        else:
            # Direct HTML parsing
            if not hasattr(victories, 'soup') or not victories.soup:
                return f"No victories data found for rider ID {rider_id}. This rider ID may not exist or has no recorded victories."
            
            soup = victories.soup
            
            # Find victories table
            victories_table = None
            tables = soup.find_all('table')
            
            # Look for the appropriate table that contains victories
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')] if table.find_all('th') else []
                if len(headers) >= 3 and any(keyword in ' '.join(headers).lower() 
                                           for keyword in ['date', 'race', 'year']):
                    victories_table = table
                    break
            
            if not victories_table:
                return f"No victories table found for rider ID {rider_id}. The rider may not have any recorded victories."
            
            # Parse victories data
            rows = victories_table.find_all('tr')
            if len(rows) <= 1:  # Only header row, no data
                return f"No victories found for rider ID {rider_id}."
            
            # Get headers to determine column positions
            headers = [th.text.strip() for th in rows[0].find_all('th')] if rows[0].find_all('th') else []
            
            # Find column indices
            year_idx = next((i for i, h in enumerate(headers) if "Year" in h), None)
            date_idx = next((i for i, h in enumerate(headers) if "Date" in h), None)
            race_idx = next((i for i, h in enumerate(headers) if "Race" in h), 1)  # Default to second column
            cat_idx = next((i for i, h in enumerate(headers) if "CAT" in h), None)
            
            # Extract and organize victories by year
            victories_by_year = {}
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data
                year = cols[year_idx].text.strip() if year_idx is not None and year_idx < len(cols) else "Unknown"
                date = cols[date_idx].text.strip() if date_idx is not None and date_idx < len(cols) else "N/A"
                race = cols[race_idx].text.strip() if race_idx is not None and race_idx < len(cols) else cols[1].text.strip()
                category = cols[cat_idx].text.strip() if cat_idx is not None and cat_idx < len(cols) else "N/A"
                
                # If year not found in date column, try to extract from date
                if year == "Unknown" and date != "N/A":
                    year_match = re.search(r'(\d{4})', date)
                    if year_match:
                        year = year_match.group(1)
                
                if year not in victories_by_year:
                    victories_by_year[year] = []
                
                victories_by_year[year].append({
                    'date': date,
                    'race': race,
                    'category': category
                })
            
            # Sort years in descending order and format output
            for year in sorted(victories_by_year.keys(), reverse=True):
                info += f"{year}:\n"
                
                for victory in victories_by_year[year]:
                    result_line = f"  {victory['date']} - {victory['race']}"
                    if victory['category'] and victory['category'] != 'N/A':
                        result_line += f" ({victory['category']})"
                    
                    info += result_line + "\n"
                
                info += "\n"
            
            if not victories_by_year:
                info += "No victories found.\n"
        
        return info
    except Exception as e:
        return f"Error retrieving victories for rider ID {rider_id}: {str(e)}"

@mcp.tool(
    name="get_rider_teams",
    description="""Get a detailed history of a professional cyclist's team affiliations throughout their career.
    This tool provides a chronological list of all teams the rider has been part of, including years and team details.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get team history for Peter Sagan (ID: 12345)
    - Get career team changes for Chris Froome (ID: 67890)
    
    Returns a formatted string with:
    - Complete team history
    - Years with each team
    - Team names and details
    - Chronological organization"""
)
async def get_rider_teams(rider_id: int) -> str:
    """Get a detailed history of a professional cyclist's team affiliations throughout their career.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 12345 for Peter Sagan)
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get teams history
        teams_history = rider.teams()
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(teams_history, 'header_details') and teams_history.header_details:
            if 'name' in teams_history.header_details:
                rider_name = teams_history.header_details['name']
            else:
                # Try to find name in soup
                if hasattr(teams_history, 'soup') and teams_history.soup:
                    name_element = teams_history.soup.find('h1')
                    if name_element:
                        rider_name = name_element.text.strip()
        
        # Format title
        if rider_name:
            info += f"Team History for {rider_name}:\n\n"
        else:
            info += f"Team History for Rider ID {rider_id}:\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(teams_history, 'results_df') and not (teams_history.results_df is None or teams_history.results_df.empty):
            # Use standard parsing
            results_df = teams_history.results_df
            
            # Sort by year (most recent first)
            results_df = results_df.sort_values('Year', ascending=False)
            
            for _, row in results_df.iterrows():
                year = row.get('Year', 'N/A')
                team = row.get('Team', 'N/A')
                
                info += f"{year}: {team}\n"
        else:
            # Direct HTML parsing
            if not hasattr(teams_history, 'soup') or not teams_history.soup:
                return f"No team history found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = teams_history.soup
            
            # Find teams table
            teams_table = None
            tables = soup.find_all('table')
            
            # Look for the appropriate table that contains team history
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')] if table.find_all('th') else []
                if len(headers) >= 2 and any(keyword in ' '.join(headers).lower() 
                                           for keyword in ['year', 'team', 'season']):
                    teams_table = table
                    break
            
            if not teams_table:
                # Try to find any table that might contain years and teams
                for table in tables:
                    rows = table.find_all('tr')
                    if len(rows) >= 2:  # At least a header and one data row
                        # Check first data row for year-like and team-like content
                        cols = rows[1].find_all('td')
                        if len(cols) >= 2:
                            # Check if first column contains a year
                            if re.match(r'\d{4}', cols[0].text.strip()):
                                teams_table = table
                                break
            
            if not teams_table:
                return f"No team history table found for rider ID {rider_id}."
            
            # Parse teams data
            rows = teams_table.find_all('tr')
            if len(rows) <= 1:  # Only header row, no data
                return f"No team history found for rider ID {rider_id}."
            
            # Get headers to determine column positions
            headers = [th.text.strip() for th in rows[0].find_all('th')] if rows[0].find_all('th') else []
            
            # Find column indices
            year_idx = next((i for i, h in enumerate(headers) if "Year" in h), 0)  # Default to first column
            team_idx = next((i for i, h in enumerate(headers) if "Team" in h), 1)  # Default to second column
            
            # Extract teams by year
            teams_by_year = []
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 2:  # Ensure it's a data row
                    continue
                
                # Extract data
                year = cols[year_idx].text.strip() if year_idx < len(cols) else "Unknown"
                team = cols[team_idx].text.strip() if team_idx < len(cols) else cols[1].text.strip()
                
                # Sanitize data
                if year and team:
                    teams_by_year.append({
                        'year': year,
                        'team': team
                    })
            
            # Sort years in descending order and format output
            teams_by_year.sort(key=lambda x: x['year'], reverse=True)
            
            for team_entry in teams_by_year:
                info += f"{team_entry['year']}: {team_entry['team']}\n"
            
            if not teams_by_year:
                info += "No team history found.\n"
        
        return info
    except Exception as e:
        return f"Error retrieving team history for rider ID {rider_id}: {str(e)}"

@mcp.tool(
    name="search_rider",
    description="""Search for professional cyclists by name. This tool helps find riders by their name, 
    returning a list of matching riders with their IDs and basic information. This is useful when you need 
    a rider's ID for other operations but only know their name.
    
    Example usage:
    - Search for "Tadej Pogacar" to find Tadej Pogačar's ID
    - Search for "Van Aert" to find Wout van Aert's ID
    
    Returns a formatted string with:
    - List of matching riders
    - Each rider's ID, name, nationality, and current team
    - Number of matches found"""
)
async def search_rider(query: str) -> str:
    """Search for riders by name.

    Args:
        query (str): The search query string to find riders by name.

    Returns:
        str: A formatted string containing matching riders with their details:
             - Rider ID
             - Rider name
             - Nationality
             - Current team
    """
    try:
        # Search for riders using the Rider.search method
        riders = Rider.search(query)
        
        if not riders:
            return f"No riders found matching the query '{query}'."
        
        # Build results string
        info = f"Found {len(riders)} riders matching '{query}':\n\n"
        
        for rider in riders:
            info += f"ID: {rider['id']}\n"
            info += f"Name: {rider['name']}\n"
            if rider.get('nationality'):
                info += f"Nationality: {rider['nationality'].upper()}\n"
            if rider.get('team'):
                info += f"Team: {rider['team']}\n"
            info += "\n"
        
        return info
    except Exception as e:
        return f"Error searching for riders: {str(e)}"

@mcp.tool(
    name="get_rider_info",
    description="""Get comprehensive information about a professional cyclist including their current team, nationality, date of birth, and recent race results. 
    This tool provides a detailed overview of a rider's current status and recent performance in professional cycling races. 
    The information includes their current team affiliation, nationality, age, and their most recent race results with positions and times.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get basic info for Tadej Pogačar (ID: 16973)
    - Get basic info for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Full name and current team
    - Nationality and date of birth
    - UCI ID and social media handles
    - Last 5 race results with positions and times
    - Total number of UCI victories"""
)
async def get_rider_info(rider_id: int) -> str:
    """Get basic information about a rider.

    Args:
        rider_id (int): The unique identifier for the rider. This ID can be found on FirstCycling.com
                       in the rider's profile URL (e.g., for rider 12345, the URL would be firstcycling.com/rider/12345).

    Returns:
        str: A formatted string containing the rider's information including:
             - Full name
             - Current team (if available)
             - Nationality
             - Date of birth
             - Recent race results (last 5 races) with positions and times

    Raises:
        Exception: If the rider is not found or if there are connection issues.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Use direct HTML parsing approach to handle cases where the regular parsing fails
        try:
            # Try to get rider year results using standard method
            year_results = rider.year_results()
            
            # Check if results exist
            if year_results is None or not hasattr(year_results, 'results_df') or year_results.results_df.empty:
                raise Exception("No results found using standard method")
            
            # Extract details from the response
            header_details = year_results.header_details
            sidebar_details = year_results.sidebar_details
            
            # Build rider information string
            info = ""
            
            # Add name from header details
            if header_details and 'name' in header_details:
                info += f"Name: {header_details['name']}\n"
            else:
                info += f"Rider ID: {rider_id}\n"
            
            # Add team if available
            if header_details and 'current_team' in header_details:
                info += f"Team: {header_details['current_team']}\n"
            
            # Add Twitter/social media if available
            if header_details and 'twitter_handle' in header_details:
                info += f"Twitter: @{header_details['twitter_handle']}\n"
            
            # Add information from sidebar details
            if sidebar_details:
                if 'Nationality' in sidebar_details:
                    info += f"Nationality: {sidebar_details['Nationality']}\n"
                if 'Date of Birth' in sidebar_details:
                    info += f"Date of Birth: {sidebar_details['Date of Birth']}\n"
                if 'UCI ID' in sidebar_details:
                    info += f"UCI ID: {sidebar_details['UCI ID']}\n"
            
            # Get results for current year
            if hasattr(year_results, 'results_df') and not year_results.results_df.empty:
                info += "\nRecent Results:\n"
                results_count = min(5, len(year_results.results_df))
                for i in range(results_count):
                    row = year_results.results_df.iloc[i]
                    date = row.get('Date', 'N/A')
                    race = row.get('Race', 'N/A')
                    pos = row.get('Pos', 'N/A')
                    info += f"{i+1}. {date} - {race}: {pos}\n"
            
            # Add victories if available (just a count)
            try:
                victories = rider.victories(uci=True)
                if hasattr(victories, 'results_df') and not victories.results_df.empty:
                    info += f"\nUCI Victories: {len(victories.results_df)}\n"
            except:
                pass
            
            return info
            
        except Exception as parsing_error:
            # If standard parsing method fails, use direct HTML parsing
            # Get raw HTML for the rider page
            url = f"https://firstcycling.com/rider.php?r={rider_id}"
            response = requests.get(url)
            
            if response.status_code != 200:
                return f"Failed to retrieve data for rider ID {rider_id}. Status code: {response.status_code}"
            
            # Parse the HTML
            soup = BeautifulSoup(response.text, 'html.parser')
            
            # Check if the page indicates the rider doesn't exist
            if "not found" in soup.text.lower() or "no results found" in soup.text.lower():
                return f"Rider ID {rider_id} does not exist on FirstCycling.com."
            
            # Build rider information string
            info = ""
            
            # Get rider name from the heading
            name_element = soup.find('h1')
            if name_element:
                rider_name = name_element.text.strip()
                info += f"Name: {rider_name}\n"
            else:
                info += f"Rider ID: {rider_id}\n"
            
            # Get current team - typically in a div after the rider name
            team_element = soup.find('span', class_='blue')
            if team_element:
                team_name = team_element.text.strip()
                info += f"Team: {team_name}\n"
            
            # Try to find the sidebar details (nationality, birth date, etc.)
            sidebar = soup.find('div', class_='rp-info')
            if sidebar:
                detail_rows = sidebar.find_all('tr')
                for row in detail_rows:
                    cells = row.find_all('td')
                    if len(cells) >= 2:
                        key = cells[0].text.strip().rstrip(':')
                        value = cells[1].text.strip()
                        if key and value:
                            info += f"{key}: {value}\n"
            
            # Try to find recent results
            tables = soup.find_all('table')
            results_table = None
            
            # Look for a table that has race results
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and ('Date' in headers or 'Race' in headers):
                    results_table = table
                    break
            
            if results_table:
                # Get the headers to identify column positions
                headers = [th.text.strip() for th in results_table.find_all('th')]
                date_idx = headers.index('Date') if 'Date' in headers else None
                race_idx = headers.index('Race') if 'Race' in headers else None
                pos_idx = headers.index('Pos') if 'Pos' in headers else None
                
                if date_idx is not None and race_idx is not None and pos_idx is not None:
                    # Extract up to 5 recent results
                    rows = results_table.find_all('tr')[1:6]  # Skip header row, take up to 5 rows
                    
                    if rows:
                        info += "\nRecent Results:\n"
                        for i, row in enumerate(rows):
                            cells = row.find_all('td')
                            if len(cells) > max(date_idx, race_idx, pos_idx):
                                date = cells[date_idx].text.strip()
                                race = cells[race_idx].text.strip()
                                pos = cells[pos_idx].text.strip()
                                info += f"{i+1}. {date} - {race}: {pos}\n"
            
            # Try to find victories count
            # This can be tricky with direct parsing, often in a different section
            victories_section = soup.find(text=lambda text: text and 'victories' in text.lower())
            if victories_section:
                # Try to extract the number from text like "X UCI victories"
                victory_text = victories_section.strip()
                victory_match = re.search(r'(\d+)\s+UCI\s+victories', victory_text, re.IGNORECASE)
                if victory_match:
                    victories_count = victory_match.group(1)
                    info += f"\nUCI Victories: {victories_count}\n"
            
            return info
    except Exception as e:
        return f"Error retrieving rider information for ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_rider_best_results",
    description="""Retrieve the best career results of a professional cyclist, including their top finishes in various races. 
    This tool provides a comprehensive overview of a rider's most significant achievements throughout their career, 
    including their highest positions in major races, stage wins, and overall classifications. 
    Results are sorted by importance and include detailed information about each race.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get top 10 best results for Tadej Pogačar (ID: 16973)
    - Get top 5 best results for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Rider's name and career highlights
    - Top results sorted by importance
    - Race details including category and country
    - Date and position for each result"""
)
async def get_rider_best_results(rider_id: int, limit: int = 10) -> str:
    """Get the best results of a rider throughout their career.

    Args:
        rider_id (int): The unique identifier for the rider. This ID can be found on FirstCycling.com
                       in the rider's profile URL (e.g., for rider 12345, the URL would be firstcycling.com/rider/12345).
        limit (int, optional): The maximum number of results to return. Defaults to 10.
                             This parameter helps control the amount of data returned and can be adjusted
                             based on the level of detail needed. Maximum recommended value is 20.

    Returns:
        str: A formatted string containing the rider's best results, including:
             - Race name and edition
             - Date of the race
             - Position achieved
             - Time or gap to winner (if applicable)
             - Race category and type
             - Any special achievements (e.g., stage wins, points classification)

    Raises:
        Exception: If the rider is not found or if there are connection issues.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get best results
        best_results = rider.best_results()
        
        # Check if results exist
        if best_results is None or not hasattr(best_results, 'results_df') or best_results.results_df.empty:
            return f"No best results found for rider ID {rider_id}. Check if this rider has results on FirstCycling.com."
        
        # Build results information string
        info = ""
        
        # Add rider name if available from header details
        if hasattr(best_results, 'header_details') and best_results.header_details and best_results.header_details.get('current_team'):
            rider_name = best_results.soup.find('h1').text.strip() if best_results.soup.find('h1') else f"Rider ID {rider_id}"
            info += f"Best Results for {rider_name}:\n\n"
        else:
            info += f"Best Results for Rider ID {rider_id}:\n\n"
        
        # Get top results
        results_df = best_results.results_df.head(limit)
        
        for _, row in results_df.iterrows():
            pos = row.get('Pos', 'N/A')
            race = row.get('Race', 'N/A')
            editions = row.get('Editions', 'N/A')
            category = row.get('CAT', '')
            country = row.get('Race_Country', '')
            
            result_line = f"{pos}. {race}"
            if category:
                result_line += f" ({category})"
            if editions != 'N/A':
                result_line += f" - {editions}"
            if country:
                result_line += f" - {country}"
            info += result_line + "\n"
        
        return info
    except Exception as e:
        return f"Error retrieving best results for rider ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_rider_grand_tour_results",
    description="""Get comprehensive results for a rider in Grand Tours (Tour de France, Giro d'Italia, and Vuelta a España). 
    This tool provides detailed information about a rider's performance in cycling's most prestigious three-week races, 
    including their overall classification positions, stage wins, and special classification results. 
    The data is organized chronologically and includes all relevant race details.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get Grand Tour results for Tadej Pogačar (ID: 16973)
    - Get Grand Tour results for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Results for each Grand Tour (Tour de France, Giro, Vuelta)
    - Overall classification positions
    - Stage wins and special classification results
    - Time gaps and race details"""
)
async def get_rider_grand_tour_results(rider_id: int) -> str:
    """Get results for a rider in Grand Tours.

    Args:
        rider_id (int): The unique identifier for the rider. This ID can be found on FirstCycling.com
                       in the rider's profile URL (e.g., for rider 12345, the URL would be firstcycling.com/rider/12345).

    Returns:
        str: A formatted string containing the rider's Grand Tour results, including:
             - Race name and year
             - Overall classification position
             - Time or gap to winner
             - Stage wins (if any)
             - Points classification results
             - Mountains classification results
             - Young rider classification results (if applicable)
             - Team classification results

    Raises:
        Exception: If the rider is not found or if there are connection issues.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get grand tour results
        grand_tour_results = rider.grand_tour_results()
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(grand_tour_results, 'header_details') and grand_tour_results.header_details and 'name' in grand_tour_results.header_details:
            rider_name = grand_tour_results.header_details['name']
        else:
            # Try to extract rider name from page title
            if hasattr(grand_tour_results, 'soup') and grand_tour_results.soup:
                title = grand_tour_results.soup.find('title')
                if title and '|' in title.text:
                    rider_name = title.text.split('|')[0].strip()
        
        # Format title
        if rider_name:
            info += f"Grand Tour Results for {rider_name}:\n\n"
        else:
            info += f"Grand Tour Results for Rider ID {rider_id}:\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(grand_tour_results, 'results_df') and not (grand_tour_results.results_df is None or grand_tour_results.results_df.empty):
            # Use standard parsing
            results_df = grand_tour_results.results_df
            
            # Group results by race
            for race in results_df['Race'].unique():
                race_results = results_df[results_df['Race'] == race]
                info += f"{race}:\n"
                
                # Sort by year (most recent first)
                race_results = race_results.sort_values('Year', ascending=False)
                
                for _, row in race_results.iterrows():
                    year = row.get('Year', 'N/A')
                    pos = row.get('Pos', 'N/A')
                    time = row.get('Time', '')
                    
                    result_line = f"  {year}: {pos}"
                    if time:
                        result_line += f" - {time}"
                    info += result_line + "\n"
                
                info += "\n"
        else:
            # Direct HTML parsing
            if not hasattr(grand_tour_results, 'soup') or not grand_tour_results.soup:
                return f"No Grand Tour results found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = grand_tour_results.soup
            
            # Find Grand Tour results table
            tables = soup.find_all('table')
            gt_table = None
            
            # Look for the appropriate table that contains Grand Tour results
            # Usually it's a table with "Tour de France", "Giro d'Italia", or "Vuelta a España" mentioned
            grand_tours = ["Tour de France", "Giro d'Italia", "Vuelta a España"]
            
            for table in tables:
                for gt in grand_tours:
                    if gt in table.text:
                        gt_table = table
                        break
                if gt_table:
                    break
                
                # If not found by name, look for a table with "Race" and "Year" columns
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and "Race" in headers and "Year" in headers:
                    gt_table = table
                    break
            
            if not gt_table:
                return f"Could not find Grand Tour results table for rider ID {rider_id}."
            
            # Parse Grand Tour data
            rows = gt_table.find_all('tr')
            gt_data = []
            
            # Get column indices from header row
            headers = [th.text.strip() for th in rows[0].find_all('th')]
            
            race_idx = next((i for i, h in enumerate(headers) if "Race" in h), None)
            year_idx = next((i for i, h in enumerate(headers) if "Year" in h), None)
            pos_idx = next((i for i, h in enumerate(headers) if "Pos" in h), None)
            time_idx = next((i for i, h in enumerate(headers) if "Time" in h), None)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data
                race_text = cols[race_idx].text.strip() if race_idx is not None and race_idx < len(cols) else "N/A"
                year_text = cols[year_idx].text.strip() if year_idx is not None and year_idx < len(cols) else "N/A"
                pos_text = cols[pos_idx].text.strip() if pos_idx is not None and pos_idx < len(cols) else "N/A"
                time_text = cols[time_idx].text.strip() if time_idx is not None and time_idx < len(cols) else ""
                
                # Only include if it's a Grand Tour
                if any(gt in race_text for gt in grand_tours):
                    gt_data.append({
                        'Race': race_text,
                        'Year': year_text,
                        'Pos': pos_text,
                        'Time': time_text
                    })
            
            # Group by race
            race_grouped = {}
            for result in gt_data:
                race = result['Race']
                if race not in race_grouped:
                    race_grouped[race] = []
                race_grouped[race].append(result)
            
            # Format output by race
            for race, results in race_grouped.items():
                info += f"{race}:\n"
                
                # Sort by year (most recent first)
                results.sort(key=lambda x: x['Year'], reverse=True)
                
                for result in results:
                    result_line = f"  {result['Year']}: {result['Pos']}"
                    if result['Time']:
                        result_line += f" - {result['Time']}"
                    info += result_line + "\n"
                
                info += "\n"
            
            if not gt_data:
                info += "No Grand Tour results found for this rider.\n"
        
        return info
    except Exception as e:
        return f"Error retrieving Grand Tour results for rider ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_rider_monument_results",
    description="""Retrieve detailed results for a rider in cycling's five Monument races (Milan-San Remo, Tour of Flanders, 
    Paris-Roubaix, Liège-Bastogne-Liège, and Il Lombardia). These are the most prestigious one-day races in professional cycling. 
    The tool provides comprehensive information about a rider's performance in these historic races, including their positions, 
    times, and any special achievements.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get Monument results for Tadej Pogačar (ID: 16973)
    - Get Monument results for Mathieu van der Poel (ID: 16975)
    
    Returns a formatted string with:
    - Results for each Monument race
    - Position and time for each participation
    - Race details and special achievements
    - Chronological organization by year"""
)
async def get_rider_monument_results(rider_id: int) -> str:
    """Get results for a rider in the five Monument races.

    Args:
        rider_id (int): The unique identifier for the rider. This ID can be found on FirstCycling.com
                       in the rider's profile URL (e.g., for rider 12345, the URL would be firstcycling.com/rider/12345).

    Returns:
        str: A formatted string containing the rider's Monument race results, including:
             - Race name and year
             - Position achieved
             - Time or gap to winner
             - Race distance
             - Any special achievements or notable moments
             - Team performance

    Raises:
        Exception: If the rider is not found or if there are connection issues.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get monument results
        monument_results = rider.monument_results()
        
        # Check if results exist
        if monument_results is None or not hasattr(monument_results, 'results_df') or monument_results.results_df.empty:
            return f"No Monument results found for rider ID {rider_id}. This rider ID may not exist."
        
        # Build results information string
        info = ""
        
        # Add rider name if available from header details
        if hasattr(monument_results, 'header_details') and monument_results.header_details and 'name' in monument_results.header_details:
            info += f"Monument Results for {monument_results.header_details['name']}:\n\n"
        else:
            info += f"Monument Results for Rider ID {rider_id}:\n\n"
        
        # Get results for each Monument
        monument_races = {
            "Milano-Sanremo": [],
            "Paris-Roubaix": [],
            "Ronde van Vlaanderen": [],
            "Liège-Bastogne-Liège": [],
            "Il Lombardia": []
        }
        
        # Group results by monument races
        for _, row in monument_results.results_df.iterrows():
            race_name = row.get('Race', '')
            year = row.get('Year', '')
            position = row.get('Pos', '')
            
            # Check if this is one of the 5 monuments
            for monument in monument_races:
                if monument in race_name:
                    monument_races[monument].append((year, position))
                    break
        
        # Format and add results for each monument
        for monument, results in monument_races.items():
            if not results:
                continue
                
            info += f"{monument}:\n"
            
            # Sort results by year in descending order
            results.sort(key=lambda x: x[0], reverse=True)
            
            for year, position in results:
                info += f"  {year}: {position}\n"
            
            info += "\n"
        
        return info
    except Exception as e:
        return f"Error retrieving Monument results for rider ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_rider_team_and_ranking",
    description="""Get information about a professional cyclist's team affiliations and UCI rankings throughout their career.
    This tool retrieves the rider's team history and their UCI ranking points over time. It provides a comprehensive
    overview of their professional career progression through different teams and their performance in the UCI rankings.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get team and ranking history for Tadej Pogačar (ID: 16973)
    - Get team and ranking history for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Complete team history with years
    - UCI ranking positions and points
    - Career progression timeline
    - Current team and ranking status"""
)
async def get_rider_team_and_ranking(rider_id: int) -> str:
    """Get information about a professional cyclist's team affiliations and UCI rankings throughout their career.

    This tool retrieves the rider's team history and their UCI ranking points over time. It provides a comprehensive
    overview of their professional career progression through different teams and their performance in the UCI rankings.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16973 for Tadej Pogačar)
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get team and ranking information
        team_ranking = rider.team_and_ranking()
        
        # Build information string
        info = ""
        
        # Add rider name if available from header details
        if hasattr(team_ranking, 'header_details') and team_ranking.header_details and 'name' in team_ranking.header_details:
            rider_name = team_ranking.header_details['name']
            info += f"Team and Ranking History for {rider_name}:\n\n"
        else:
            # Try to extract rider name from page title
            if hasattr(team_ranking, 'soup'):
                title = team_ranking.soup.find('title')
                if title and '|' in title.text:
                    rider_name = title.text.split('|')[0].strip()
                    info += f"Team and Ranking History for {rider_name}:\n\n"
                else:
                    info += f"Team and Ranking History for Rider ID {rider_id}:\n\n"
            else:
                info += f"Team and Ranking History for Rider ID {rider_id}:\n\n"
        
        # Check if we need to use the default parsing or direct HTML parsing
        if hasattr(team_ranking, 'results_df') and not (team_ranking.results_df is None or team_ranking.results_df.empty):
            # Use the default parsed results
            results_df = team_ranking.results_df
            
            # Sort by year (most recent first)
            results_df = results_df.sort_values('Year', ascending=False)
            
            # Group by year
            for year in results_df['Year'].unique():
                year_data = results_df[results_df['Year'] == year]
                info += f"{year}:\n"
                
                # Get team information
                team = year_data['Team'].iloc[0] if not year_data['Team'].empty else 'N/A'
                info += f"  Team: {team}\n"
                
                # Get ranking information
                ranking = year_data['Ranking'].iloc[0] if not year_data['Ranking'].empty else 'N/A'
                points = year_data['Points'].iloc[0] if not year_data['Points'].empty else 'N/A'
                
                if ranking != 'N/A' or points != 'N/A':
                    info += "  UCI Ranking: "
                    if ranking != 'N/A':
                        info += f"{ranking}"
                    if points != 'N/A':
                        info += f" ({points} points)"
                    info += "\n"
                
                info += "\n"
        else:
            # Direct HTML parsing if results_df is not available
            if not hasattr(team_ranking, 'soup'):
                return f"No team and ranking information found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = team_ranking.soup
            
            # Look for team and ranking information in tables
            tables = soup.find_all('table')
            stats_table = None
            
            # Find the table with team and ranking information
            # Usually, it's a table with "Year", "Team", "Ranking", "Points" headers
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and "Year" in headers and "Team" in headers:
                    stats_table = table
                    break
            
            if stats_table is None:
                return f"No team and ranking information could be found for rider ID {rider_id}."
            
            # Parse the table rows
            rows = stats_table.find_all('tr')
            
            # Skip the header row
            data = []
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) >= 3:  # Ensure we have enough columns
                    year = cols[0].text.strip()
                    
                    # Extract team (might be in a link)
                    team_col = cols[1]
                    team_link = team_col.find('a')
                    team = team_link.text.strip() if team_link else team_col.text.strip()
                    
                    # Extract ranking and points 
                    # (format can vary but typically in columns 2 and 3)
                    ranking = cols[2].text.strip() if len(cols) > 2 else 'N/A'
                    points = cols[3].text.strip() if len(cols) > 3 else 'N/A'
                    
                    data.append({
                        'Year': year,
                        'Team': team,
                        'Ranking': ranking,
                        'Points': points
                    })
            
            # Sort by year (most recent first)
            data.sort(key=lambda x: x['Year'], reverse=True)
            
            # Build the information string
            for item in data:
                info += f"{item['Year']}:\n"
                info += f"  Team: {item['Team']}\n"
                
                if item['Ranking'] != 'N/A' or item['Points'] != 'N/A':
                    info += "  UCI Ranking: "
                    if item['Ranking'] != 'N/A':
                        info += f"{item['Ranking']}"
                    if item['Points'] != 'N/A':
                        info += f" ({item['Points']} points)"
                    info += "\n"
                
                info += "\n"
            
            if not data:
                return f"No team and ranking information could be parsed for rider ID {rider_id}."
        
        return info
    except Exception as e:
        return f"An error occurred while getting team and ranking information for rider ID {rider_id}: {str(e)}"

@mcp.tool(
    name="get_rider_race_history",
    description="""Get the complete race history of a professional cyclist, optionally filtered by year.
    This tool retrieves a comprehensive list of all races the rider has participated in, including their
    positions, times, and race categories. It provides a detailed overview of their racing career.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get complete race history for Tadej Pogačar (ID: 16973)
    - Get 2023 race history for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - All races organized by year
    - Position and time for each race
    - Race category and details
    - Chronological organization"""
)
async def get_rider_race_history(rider_id: int, year: int = None) -> str:
    """Get the complete race history of a professional cyclist, optionally filtered by year.

    This tool retrieves a comprehensive list of all races the rider has participated in, including their
    positions, times, and race categories. It provides a detailed overview of their racing career.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16973 for Tadej Pogačar)
        year: Optional year to filter results (e.g., 2023). If not provided, returns all years.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get race history
        race_history = rider.race_history()
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(race_history, 'header_details') and race_history.header_details and 'name' in race_history.header_details:
            rider_name = race_history.header_details['name']
        else:
            # Try to extract rider name from page title
            if hasattr(race_history, 'soup') and race_history.soup:
                title = race_history.soup.find('title')
                if title and '|' in title.text:
                    rider_name = title.text.split('|')[0].strip()
        
        # Format title
        if rider_name:
            info += f"Race History for {rider_name}"
        else:
            info += f"Race History for Rider ID {rider_id}"
        
        if year:
            info += f" ({year})"
        info += ":\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(race_history, 'results_df') and not (race_history.results_df is None or race_history.results_df.empty):
            # Use standard parsing
            results_df = race_history.results_df
            
            # Filter by year if specified
            if year:
                results_df = results_df[results_df['Year'] == year]
            
            # Sort by date (most recent first)
            results_df = results_df.sort_values('Date', ascending=False)
            
            # Group by year
            for year_val in results_df['Year'].unique():
                year_data = results_df[results_df['Year'] == year_val]
                info += f"{year_val}:\n"
                
                for _, row in year_data.iterrows():
                    date = row.get('Date', 'N/A')
                    race = row.get('Race', 'N/A')
                    pos = row.get('Pos', 'N/A')
                    category = row.get('CAT', 'N/A')
                    time = row.get('Time', '')
                    
                    result_line = f"  {date} - {race} ({category}): {pos}"
                    if time:
                        result_line += f" - {time}"
                    info += result_line + "\n"
                
                info += "\n"
        else:
            # Direct HTML parsing
            if not hasattr(race_history, 'soup') or not race_history.soup:
                return f"No race history found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = race_history.soup
            
            # Find race history table
            tables = soup.find_all('table')
            race_table = None
            
            # First try to find tables with specific headers
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and any(("Date" in h or "Race" in h or "Pos" in h) for h in headers):
                    race_table = table
                    break
            
            # If not found, look for any table that might contain race data
            if not race_table and tables:
                # Try to find a table with typical race data structure (multiple rows with dates, etc.)
                for table in tables:
                    rows = table.find_all('tr')
                    if len(rows) >= 3:  # Header row + at least 2 data rows
                        # Check if any cell in the first row contains date-like text
                        first_row_cells = rows[1].find_all('td')
                        for cell in first_row_cells:
                            cell_text = cell.text.strip()
                            # Look for date patterns like DD.MM or YYYY or MM/DD
                            if (len(cell_text) >= 4 and 
                                ('.' in cell_text or '/' in cell_text or '-' in cell_text or 
                                 (cell_text.isdigit() and int(cell_text) > 2000 and int(cell_text) < 2030))):
                                race_table = table
                                break
                    if race_table:
                        break
            
            # If we still couldn't find a table, direct URL request to races page
            if not race_table:
                # Try to directly access the races page
                races_url = f"https://firstcycling.com/rider.php?r={rider_id}&races=2"
                try:
                    races_response = requests.get(races_url)
                    if races_response.status_code == 200:
                        races_soup = BeautifulSoup(races_response.text, 'html.parser')
                        tables = races_soup.find_all('table')
                        
                        # Look for tables with race data
                        for table in tables:
                            headers = [th.text.strip() for th in table.find_all('th')]
                            if len(headers) >= 3 and any(keyword in ' '.join(headers).lower() 
                                                        for keyword in ['date', 'race', 'result', 'position']):
                                race_table = table
                                break
                except Exception as table_error:
                    # If direct access fails, continue with the original soup
                    pass
            
            if not race_table:
                # Get the rider name for a more helpful error message
                rider_name_text = ""
                try:
                    if hasattr(race_history, 'soup'):
                        name_element = race_history.soup.find('h1')
                        if name_element:
                            rider_name_text = f" ({name_element.text.strip()})"
                except:
                    pass
                
                return f"Could not find race history table for rider ID {rider_id}{rider_name_text}. The data may not be available on FirstCycling."
            
            # Parse race data
            rows = race_table.find_all('tr')
            race_data = []
            
            # Get column indices from header row
            headers = [th.text.strip() for th in rows[0].find_all('th')] if rows and rows[0].find_all('th') else []
            
            # Determine column positions, with fallbacks if headers aren't clear
            date_idx = next((i for i, h in enumerate(headers) if "Date" in h), 0)  # Default to first column
            race_idx = next((i for i, h in enumerate(headers) if "Race" in h), 1)  # Default to second column
            pos_idx = next((i for i, h in enumerate(headers) if "Pos" in h or "Result" in h), 2)  # Default to third column
            cat_idx = next((i for i, h in enumerate(headers) if "CAT" in h or "Category" in h), None)  # May not exist
            
            # Skip header row if it exists
            start_row = 1 if headers else 0
            
            for row in rows[start_row:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data
                date_text = cols[date_idx].text.strip() if date_idx is not None and date_idx < len(cols) else "N/A"
                race_text = cols[race_idx].text.strip() if race_idx is not None and race_idx < len(cols) else "N/A"
                pos_text = cols[pos_idx].text.strip() if pos_idx is not None and pos_idx < len(cols) else "N/A"
                cat_text = cols[cat_idx].text.strip() if cat_idx is not None and cat_idx < len(cols) else "N/A"
                
                # Extract year from date (format may vary, but often includes year)
                race_year = None
                if date_text != "N/A":
                    # Try common date formats to extract year
                    if len(date_text) >= 4:
                        try:
                            # If year is last part (e.g., "01.01.2023")
                            race_year = int(date_text[-4:])
                        except Exception:
                            # If year is first part (e.g., "2023-01-01")
                            try:
                                race_year = int(date_text[:4])
                            except Exception:
                                pass
                
                if race_year:
                    # Skip if a specific year was requested and this race is from a different year
                    if year and race_year != year:
                        continue
                    
                    race_data.append({
                        'Year': race_year,
                        'Date': date_text,
                        'Race': race_text,
                        'Pos': pos_text,
                        'CAT': cat_text
                    })
            
            # Group by year
            year_grouped = {}
            for race in race_data:
                year_val = race['Year']
                if year_val not in year_grouped:
                    year_grouped[year_val] = []
                year_grouped[year_val].append(race)
            
            # Sort years (most recent first)
            for year_val in sorted(year_grouped.keys(), reverse=True):
                races = year_grouped[year_val]
                info += f"{year_val}:\n"
                
                for race in races:
                    result_line = f"  {race['Date']} - {race['Race']} ({race['CAT']}): {race['Pos']}"
                    info += result_line + "\n"
                
                info += "\n"
            
            if not race_data:
                info += "No race history found for this rider.\n"
        
        return info
    except Exception as e:
        return f"Error searching for riders: {str(e)}"

@mcp.tool(
    name="search_race",
    description="""Search for cycling races by name. This tool helps find races by their name, 
    returning a list of matching races with their IDs and countries. This is useful when you know 
    a race's name but need its ID for other operations.
    
    Example usage:
    - Search for "tour" to find Tour de France and other tours
    - Search for "giro" to find Giro d'Italia
    
    Returns a formatted string with:
    - List of matching races
    - Each race's ID, name, and country
    - Number of matches found"""
)
async def search_race(query: str) -> str:
    """Search for races by name.

    Args:
        query (str): The search query string to find races by name.

    Returns:
        str: A formatted string containing matching races with their details:
             - Race ID
             - Race name
             - Country
    """
    try:
        # Search for races
        races = Race.search(query)
        
        if not races:
            return f"No races found matching the query '{query}'."
        
        # Build results string
        info = f"Found {len(races)} races matching '{query}':\n\n"
        
        for race in races:
            info += f"ID: {race['id']}\n"
            info += f"Name: {race['name']}\n"
            if race['country']:
                info += f"Country: {race['country'].upper()}\n"
            info += "\n"
        
        return info
    except Exception as e:
        return f"Error searching for races: {str(e)}"

@mcp.tool(
    name="get_rider_one_day_races",
    description="""Get a rider's results in one-day races, optionally filtered by year.
    This tool retrieves detailed information about a rider's performance in one-day races 
    (classics and one-day events). It provides comprehensive data about positions, times, 
    and race categories. Results can be filtered by a specific year.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get one-day race results for Mathieu van der Poel (ID: 16672)
    - Get 2023 one-day race results for Wout van Aert (ID: 16948)
    
    Returns a formatted string with:
    - Results in one-day races organized by year
    - Position and time for each race
    - Race category and details
    - Chronological organization"""
)
async def get_rider_one_day_races(rider_id: int, year: int = None) -> str:
    """Get a rider's results in one-day races, optionally filtered by year.

    This tool retrieves detailed information about a rider's performance in one-day races 
    (classics and one-day events). It provides comprehensive data about positions, times, 
    and race categories. Results can be filtered by a specific year.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16672 for Mathieu van der Poel)
        year: Optional year to filter results (e.g., 2023). If not provided, returns all years.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get one-day races results
        one_day_results = rider.one_day_races()
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(one_day_results, 'header_details') and one_day_results.header_details and 'name' in one_day_results.header_details:
            rider_name = one_day_results.header_details['name']
        else:
            # Try to extract rider name from page title
            if hasattr(one_day_results, 'soup') and one_day_results.soup:
                title = one_day_results.soup.find('title')
                if title and '|' in title.text:
                    rider_name = title.text.split('|')[0].strip()
        
        # Format title
        if rider_name:
            info += f"One-Day Race Results for {rider_name}"
        else:
            info += f"One-Day Race Results for Rider ID {rider_id}"
        
        if year:
            info += f" ({year})"
        info += ":\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(one_day_results, 'results_df') and not (one_day_results.results_df is None or one_day_results.results_df.empty):
            # Use standard parsing
            results_df = one_day_results.results_df
            
            # Filter by year if specified
            if year:
                results_df = results_df[results_df['Year'] == year]
            
            # Sort by year (most recent first)
            results_df = results_df.sort_values('Year', ascending=False)
            
            # Group by year
            for year_val in results_df['Year'].unique():
                year_data = results_df[results_df['Year'] == year_val]
                info += f"{year_val}:\n"
                
                # Sort by date within year
                year_data = year_data.sort_values('Date', ascending=False)
                
                for _, row in year_data.iterrows():
                    date = row.get('Date', 'N/A')
                    race = row.get('Race', 'N/A')
                    pos = row.get('Pos', 'N/A')
                    category = row.get('CAT', 'N/A')
                    
                    info += f"  {date} - {race} ({category}): {pos}\n"
                
                info += "\n"
        else:
            # Direct HTML parsing
            if not hasattr(one_day_results, 'soup') or not one_day_results.soup:
                return f"No one-day race results found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = one_day_results.soup
            
            # Find one-day races results table
            tables = soup.find_all('table')
            results_table = None
            
            # Look for the appropriate table that contains one-day races results
            for table in tables:
                # Check table headers to find the right one
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and "Race" in headers and ("Date" in headers or "Year" in headers):
                    results_table = table
                    break
            
            if not results_table:
                return f"Could not find one-day race results table for rider ID {rider_id}."
            
            # Parse one-day races data
            rows = results_table.find_all('tr')
            race_data = []
            
            # Get column indices from header row
            headers = [th.text.strip() for th in rows[0].find_all('th')]
            
            # Find the indices of key columns
            year_idx = next((i for i, h in enumerate(headers) if "Year" in h), None)
            date_idx = next((i for i, h in enumerate(headers) if "Date" in h), None)
            race_idx = next((i for i, h in enumerate(headers) if "Race" in h), None)
            pos_idx = next((i for i, h in enumerate(headers) if "Pos" in h), None)
            cat_idx = next((i for i, h in enumerate(headers) if "CAT" in h), None)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data
                race_year = cols[year_idx].text.strip() if year_idx is not None and year_idx < len(cols) else None
                
                # If we don't have a year column, try to extract from date
                if race_year is None and date_idx is not None and date_idx < len(cols):
                    date_text = cols[date_idx].text.strip()
                    # Try to extract year from date format (e.g., 01.01.2023 or 2023-01-01)
                    try:
                        if len(date_text) >= 4:
                            if date_text[-4:].isdigit():
                                race_year = date_text[-4:]
                            elif date_text[:4].isdigit():
                                race_year = date_text[:4]
                    except Exception:
                        pass
                
                # If we still don't have a year, use the next row
                if race_year is None or not race_year.isdigit():
                    continue
                
                # Convert year to int for comparison
                race_year_int = int(race_year)
                
                # Skip if a specific year was requested and this race is from a different year
                if year and race_year_int != year:
                    continue
                
                date_text = cols[date_idx].text.strip() if date_idx is not None and date_idx < len(cols) else "N/A"
                race_text = cols[race_idx].text.strip() if race_idx is not None and race_idx < len(cols) else "N/A"
                pos_text = cols[pos_idx].text.strip() if pos_idx is not None and pos_idx < len(cols) else "N/A"
                cat_text = cols[cat_idx].text.strip() if cat_idx is not None and cat_idx < len(cols) else "N/A"
                
                race_data.append({
                    'Year': race_year_int,
                    'Date': date_text,
                    'Race': race_text,
                    'Pos': pos_text,
                    'CAT': cat_text
                })
            
            # Group by year
            year_grouped = {}
            for race in race_data:
                year_val = race['Year']
                if year_val not in year_grouped:
                    year_grouped[year_val] = []
                year_grouped[year_val].append(race)
            
            # Sort years (most recent first)
            for year_val in sorted(year_grouped.keys(), reverse=True):
                races = year_grouped[year_val]
                info += f"{year_val}:\n"
                
                # Sort by date within year (can be complex due to different date formats)
                # For now, just display as is
                for race in races:
                    info += f"  {race['Date']} - {race['Race']} ({race['CAT']}): {race['Pos']}\n"
                
                info += "\n"
            
            if not race_data:
                info += "No one-day race results found for this rider.\n"
        
        return info
    except Exception as e:
        return f"Error retrieving one-day race results for rider ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_rider_stage_races",
    description="""Get a rider's results in stage races, optionally filtered by year.
    This tool retrieves detailed information about a rider's performance in stage races
    (multi-day races like Tour de France, Giro d'Italia, etc.). It provides comprehensive data 
    about positions, times, and race categories. Results can be filtered by a specific year.
    
    Note: If you don't know the rider's ID, use the search_rider tool first to find it by name.
    
    Example usage:
    - Get stage race results for Tadej Pogačar (ID: 16973)
    - Get 2023 stage race results for Jonas Vingegaard (ID: 16974)
    
    Returns a formatted string with:
    - Results in stage races organized by year
    - Position and time for each race
    - Race category and details
    - Chronological organization"""
)
async def get_rider_stage_races(rider_id: int, year: int = None) -> str:
    """Get a rider's results in stage races, optionally filtered by year.

    This tool retrieves detailed information about a rider's performance in stage races
    (multi-day races like Tour de France, Giro d'Italia, etc.). It provides comprehensive data 
    about positions, times, and race categories. Results can be filtered by a specific year.

    Args:
        rider_id: The FirstCycling rider ID (e.g., 16973 for Tadej Pogačar)
        year: Optional year to filter results (e.g., 2023). If not provided, returns all years.
    """
    try:
        # Create a rider instance
        rider = Rider(rider_id)
        
        # Get stage races results
        stage_results = rider.stage_races()
        
        # Build information string
        info = ""
        
        # Get rider name
        rider_name = None
        if hasattr(stage_results, 'header_details') and stage_results.header_details and 'name' in stage_results.header_details:
            rider_name = stage_results.header_details['name']
        else:
            # Try to extract rider name from page title
            if hasattr(stage_results, 'soup') and stage_results.soup:
                title = stage_results.soup.find('title')
                if title and '|' in title.text:
                    rider_name = title.text.split('|')[0].strip()
        
        # Format title
        if rider_name:
            info += f"Stage Race Results for {rider_name}"
        else:
            info += f"Stage Race Results for Rider ID {rider_id}"
        
        if year:
            info += f" ({year})"
        info += ":\n\n"
        
        # Check if we need to use standard parsing or direct HTML parsing
        if hasattr(stage_results, 'results_df') and not (stage_results.results_df is None or stage_results.results_df.empty):
            # Use standard parsing
            results_df = stage_results.results_df
            
            # Filter by year if specified
            if year:
                results_df = results_df[results_df['Year'] == year]
            
            # Sort by year (most recent first)
            results_df = results_df.sort_values('Year', ascending=False)
            
            # Group by year
            for year_val in results_df['Year'].unique():
                year_data = results_df[results_df['Year'] == year_val]
                info += f"{year_val}:\n"
                
                # Sort by date within year
                year_data = year_data.sort_values('Date', ascending=False)
                
                for _, row in year_data.iterrows():
                    date = row.get('Date', 'N/A')
                    race = row.get('Race', 'N/A')
                    pos = row.get('Pos', 'N/A')
                    category = row.get('CAT', 'N/A')
                    
                    info += f"  {date} - {race} ({category}): {pos}\n"
                
                info += "\n"
        else:
            # Direct HTML parsing
            if not hasattr(stage_results, 'soup') or not stage_results.soup:
                return f"No stage race results found for rider ID {rider_id}. This rider ID may not exist."
            
            soup = stage_results.soup
            
            # Find stage races results table
            tables = soup.find_all('table')
            results_table = None
            
            # Look for the appropriate table that contains stage races results
            for table in tables:
                # Check table headers to find the right one
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and "Race" in headers and ("Date" in headers or "Year" in headers):
                    results_table = table
                    break
            
            if not results_table:
                return f"Could not find stage race results table for rider ID {rider_id}."
            
            # Parse stage races data
            rows = results_table.find_all('tr')
            race_data = []
            
            # Get column indices from header row
            headers = [th.text.strip() for th in rows[0].find_all('th')]
            
            # Find the indices of key columns
            year_idx = next((i for i, h in enumerate(headers) if "Year" in h), None)
            date_idx = next((i for i, h in enumerate(headers) if "Date" in h), None)
            race_idx = next((i for i, h in enumerate(headers) if "Race" in h), None)
            pos_idx = next((i for i, h in enumerate(headers) if "Pos" in h), None)
            cat_idx = next((i for i, h in enumerate(headers) if "CAT" in h), None)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                # Extract data
                race_year = cols[year_idx].text.strip() if year_idx is not None and year_idx < len(cols) else None
                
                # If we don't have a year column, try to extract from date
                if race_year is None and date_idx is not None and date_idx < len(cols):
                    date_text = cols[date_idx].text.strip()
                    # Try to extract year from date format (e.g., 01.01.2023 or 2023-01-01)
                    try:
                        if len(date_text) >= 4:
                            if date_text[-4:].isdigit():
                                race_year = date_text[-4:]
                            elif date_text[:4].isdigit():
                                race_year = date_text[:4]
                    except Exception:
                        pass
                
                # If we still don't have a year, use the next row
                if race_year is None or not race_year.isdigit():
                    continue
                
                # Convert year to int for comparison
                race_year_int = int(race_year)
                
                # Skip if a specific year was requested and this race is from a different year
                if year and race_year_int != year:
                    continue
                
                date_text = cols[date_idx].text.strip() if date_idx is not None and date_idx < len(cols) else "N/A"
                race_text = cols[race_idx].text.strip() if race_idx is not None and race_idx < len(cols) else "N/A"
                pos_text = cols[pos_idx].text.strip() if pos_idx is not None and pos_idx < len(cols) else "N/A"
                cat_text = cols[cat_idx].text.strip() if cat_idx is not None and cat_idx < len(cols) else "N/A"
                
                race_data.append({
                    'Year': race_year_int,
                    'Date': date_text,
                    'Race': race_text,
                    'Pos': pos_text,
                    'CAT': cat_text
                })
            
            # Group by year
            year_grouped = {}
            for race in race_data:
                year_val = race['Year']
                if year_val not in year_grouped:
                    year_grouped[year_val] = []
                year_grouped[year_val].append(race)
            
            # Sort years (most recent first)
            for year_val in sorted(year_grouped.keys(), reverse=True):
                races = year_grouped[year_val]
                info += f"{year_val}:\n"
                
                # Sort by date within year (can be complex due to different date formats)
                # For now, just display as is
                for race in races:
                    info += f"  {race['Date']} - {race['Race']} ({race['CAT']}): {race['Pos']}\n"
                
                info += "\n"
            
            if not race_data:
                info += "No stage race results found for this rider.\n"
        
        return info
    except Exception as e:
        return f"Error retrieving stage race results for rider ID {rider_id}: {str(e)}. The rider ID may not exist or there might be a connection issue."

@mcp.tool(
    name="get_race_details",
    description="""Get comprehensive details about a cycling race.
    This tool provides detailed information about a specific race, including its history, key statistics,
    route details, and other relevant information. The data can be filtered by specific classification.
    
    Note: If you don't know the race's ID, use the search_race tool first to find it by name.
    
    Example usage:
    - Get details for Tour de France (ID: 17)
    - Get details for Paris-Roubaix (ID: 30)
    
    Returns a formatted string with:
    - Race name, country, and category
    - Historical information and key statistics
    - Course details and characteristics
    - Optional classification details"""
)
async def get_race_details(race_id: int, classification_num: int = None) -> str:
    """Get comprehensive details about a cycling race.

    Args:
        race_id: The FirstCycling race ID (e.g., 17 for Tour de France)
        classification_num: Optional parameter to specify the classification (e.g., 1 for General Classification)
    """
    try:
        # Create a race instance
        race = Race(race_id)
        
        # Get race overview
        race_overview = race.overview(classification_num)
        
        # Build information string
        info = ""
        
        # Check if we can parse the data
        if not hasattr(race_overview, 'soup') or not race_overview.soup:
            return f"No race details found for race ID {race_id}. This race ID may not exist."
        
        soup = race_overview.soup
        
        # Extract race name from title
        title = soup.find('title')
        race_name = title.text.split('|')[0].strip() if title and '|' in title.text else f"Race ID {race_id}"
        
        info += f"Race Details for {race_name}:\n\n"
        
        # Extract basic information
        basic_info = {}
        
        # Look for tables with race info
        tables = soup.find_all('table')
        info_table = None
        
        for table in tables:
            if 'class' in table.attrs and 'basic' in table['class']:
                info_table = table
                break
        
        if info_table:
            rows = info_table.find_all('tr')
            for row in rows:
                cols = row.find_all('td')
                if len(cols) >= 2:
                    key = cols[0].text.strip().rstrip(':')
                    value = cols[1].text.strip()
                    if key and value:
                        basic_info[key] = value
        
        # Format basic information
        if basic_info:
            info += "Basic Information:\n"
            for key, value in basic_info.items():
                info += f"  {key}: {value}\n"
            info += "\n"
        
        # Look for course/race description
        description_div = soup.find('div', class_='w3-padding')
        if description_div:
            description_text = description_div.text.strip()
            if description_text:
                info += "Description:\n"
                info += f"  {description_text}\n\n"
        
        # Look for winners/podium information
        winners_table = None
        
        for table in tables:
            headers = [th.text.strip() for th in table.find_all('th')]
            if len(headers) >= 2 and ("Year" in headers or "Edition" in headers) and "Winner" in headers:
                winners_table = table
                break
        
        if winners_table:
            info += "Recent Winners:\n"
            
            rows = winners_table.find_all('tr')
            # Skip header row
            for i, row in enumerate(rows[1:]):
                if i >= 5:  # Limit to last 5 winners
                    break
                    
                cols = row.find_all('td')
                if len(cols) >= 2:
                    year = cols[0].text.strip()
                    winner = cols[1].text.strip()
                    
                    info += f"  {year}: {winner}\n"
            
            info += "\n"
        
        # If standard parsing doesn't work, try direct HTML parsing
        if not basic_info and not description_div and not winners_table:
            # Look for any useful information
            paragraphs = soup.find_all('p')
            for p in paragraphs:
                p_text = p.text.strip()
                if len(p_text) > 50:  # Only include substantial paragraphs
                    info += f"{p_text}\n\n"
                    
            # Extract any header information
            headers = soup.find_all(['h1', 'h2', 'h3'])
            for header in headers:
                header_text = header.text.strip()
                if race_name not in header_text:  # Avoid duplicating the race name
                    info += f"{header_text}\n"
                    
                    # Get the next element if it's a paragraph
                    next_element = header.find_next_sibling()
                    if next_element and next_element.name == 'p':
                        p_text = next_element.text.strip()
                        if p_text:
                            info += f"  {p_text}\n\n"
        
        if info == f"Race Details for {race_name}:\n\n":
            return f"Could not find specific details for race ID {race_id}."
            
        return info
    except Exception as e:
        return f"Error retrieving race details for race ID {race_id}: {str(e)}"

@mcp.tool(
    name="get_race_edition_results",
    description="""Get detailed results for a specific edition of a cycling race.
    This tool provides comprehensive results for a particular edition of a race, including rankings,
    time gaps, and other relevant statistics. Results can be filtered by classification or stage.
    
    Note: If you don't know the race's ID, use the search_race tool first to find it by name.
    
    Example usage:
    - Get 2023 Tour de France general classification results (Race ID: 17, Year: 2023)
    - Get 2022 Paris-Roubaix results (Race ID: 30, Year: 2022)
    - Get results for stage 5 of 2023 Tour de France (Race ID: 17, Year: 2023, Stage: 5)
    
    Returns a formatted string with:
    - Race name, year, and category
    - Complete result list with rankings and time gaps
    - Rider names and teams
    - Classification or stage specific information"""
)
async def get_race_edition_results(race_id: int, year: int, classification_num: int = None, stage_num: int = None) -> str:
    """Get detailed results for a specific edition of a cycling race.

    Args:
        race_id: The FirstCycling race ID (e.g., 17 for Tour de France)
        year: The year of the race edition (e.g., 2023)
        classification_num: Optional parameter to specify the classification (e.g., 1 for General Classification)
        stage_num: Optional parameter to specify the stage number (e.g., 5 for stage 5)
    """
    try:
        # Create a race instance
        race = Race(race_id)
        
        # Get specific edition
        race_edition = race.edition(year)
        
        # Get results
        results = race_edition.results(classification_num, stage_num)
        
        # Build information string
        info = ""
        
        # Check if we can parse the data
        if not hasattr(results, 'soup') or not results.soup:
            return f"No results found for race ID {race_id}, year {year}. The race may not have been held that year."
        
        soup = results.soup
        
        # Extract race name from title
        title = soup.find('title')
        race_name = title.text.split('|')[0].strip() if title and '|' in title.text else f"Race ID {race_id}"
        
        # Format title based on parameters
        info += f"{year} {race_name}"
        if stage_num is not None:
            info += f" - Stage {stage_num}"
        elif classification_num is not None:
            classification_names = {
                1: "General Classification",
                2: "Points Classification",
                3: "Mountains Classification",
                4: "Youth Classification",
                5: "Team Classification"
            }
            if classification_num in classification_names:
                info += f" - {classification_names[classification_num]}"
        info += " Results:\n\n"
        
        # Check if we have results DataFrame
        if hasattr(results, 'results_df') and not (results.results_df is None or results.results_df.empty):
            # Use standard parsing
            results_df = results.results_df
            
            # Get top results (limit to 20 for readability)
            results_df = results_df.head(20) if len(results_df) > 20 else results_df
            
            for _, row in results_df.iterrows():
                pos = row.get('Pos', 'N/A')
                rider = row.get('Rider', 'N/A')
                team = row.get('Team', 'N/A')
                time = row.get('Time', 'N/A')
                
                result_line = f"{pos}. {rider} ({team})"
                if time and time != 'N/A':
                    result_line += f" - {time}"
                
                info += result_line + "\n"
            
            if len(results_df) == 20:
                info += "...\n"
        else:
            # Direct HTML parsing
            # Find results table
            results_table = None
            tables = soup.find_all('table')
            
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if len(headers) >= 3 and "Pos" in headers:
                    results_table = table
                    break
            
            if not results_table:
                return f"Could not find results table for race ID {race_id}, year {year}."
            
            # Parse results
            rows = results_table.find_all('tr')
            
            # Get column indices
            headers = [th.text.strip() for th in rows[0].find_all('th')]
            pos_idx = next((i for i, h in enumerate(headers) if "Pos" in h), 0)
            rider_idx = next((i for i, h in enumerate(headers) if "Rider" in h), 1)
            team_idx = next((i for i, h in enumerate(headers) if "Team" in h), 2)
            time_idx = next((i for i, h in enumerate(headers) if "Time" in h), 3)
            
            # Skip header row and limit to 20 results
            max_rows = min(21, len(rows))
            
            for row in rows[1:max_rows]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                pos = cols[pos_idx].text.strip() if pos_idx < len(cols) else "N/A"
                
                # Rider name can be in a link
                rider_col = cols[rider_idx] if rider_idx < len(cols) else None
                rider = rider_col.text.strip() if rider_col else "N/A"
                
                # Team can be in a link
                team_col = cols[team_idx] if team_idx < len(cols) else None
                team = team_col.text.strip() if team_col else "N/A"
                
                time = cols[time_idx].text.strip() if time_idx < len(cols) and time_idx < len(cols) else "N/A"
                
                result_line = f"{pos}. {rider} ({team})"
                if time and time != 'N/A':
                    result_line += f" - {time}"
                
                info += result_line + "\n"
                
            if len(rows) > 21:
                info += "...\n"
        
        return info
    except Exception as e:
        return f"Error retrieving race results for race ID {race_id}, year {year}: {str(e)}"

@mcp.tool(
    name="get_start_list",
    description="""Get the start list for a specific edition of a cycling race.
    The start list includes rider numbers, names, and teams.
    
    Note: If you don't know the race's ID, use the search_race tool first to find it by name.
    If no year is specified, the current year will be used.
    
    Example usage:
    - Get start list for current year's Tour de France (Race ID: 17)
    - Get start list for 2023 Paris-Roubaix (Race ID: 30, Year: 2023)
    
    Returns a formatted string with:
    - Race name and year
    - List of participating teams
    - Riders for each team with their race numbers"""
)
async def get_start_list(race_id: int, year: int = None) -> str:
    """Get the start list for a specific edition of a cycling race.

    Args:
        race_id: The FirstCycling race ID
        year: The year of the race edition (defaults to current year if not specified)
    """
    if year is None:
        year = datetime.now().year
    
    try:
        # Create a race instance
        race = Race(race_id)
        
        # Get specific edition
        race_edition = race.edition(year)
        
        # Get start list
        start_list = race_edition.startlist()
        
        # Build information string
        info = ""
        
        # Check if we can parse the data
        if not hasattr(start_list, 'soup') or not start_list.soup:
            return f"No start list found for race ID {race_id}, year {year}. The race may not have a published start list yet."
        
        soup = start_list.soup
        
        # Extract race name from title
        title = soup.find('title')
        race_name = title.text.split('|')[0].strip() if title and '|' in title.text else f"Race ID {race_id}"
        
        # Add header
        info += f"{year} {race_name} - Start List:\n\n"
        
        # Find all team tables
        team_tables = soup.find_all('table', {'class': 'tablesorter'})
        if not team_tables:
            return f"No start list tables found for race ID {race_id}, year {year}."
        
        # Process each team table
        for table in team_tables:
            # Get team name from header
            team_header = table.find('th')
            if not team_header:
                continue
                
            # Extract team name from the link
            team_link = team_header.find('a')
            if not team_link:
                continue
                
            team_name = team_link.text.strip()
            info += f"\n{team_name}:\n"
            
            # Process riders
            for row in table.find('tbody').find_all('tr'):
                cols = row.find_all('td')
                if len(cols) < 2:  # Should have number and rider name
                    continue
                    
                number = cols[0].text.strip()
                rider_link = cols[1].find('a')
                
                if not rider_link:
                    continue
                    
                # Check if rider is crossed out (not starting)
                is_not_starting = 'text-decoration:line-through' in rider_link.get('style', '')
                
                # Get rider name parts (last name in uppercase, first name in small tag)
                last_name = rider_link.text
                first_name_tag = rider_link.find('span', class_='small')
                if first_name_tag:
                    # Remove the first name part from the full text to get the last name
                    last_name = last_name.replace(first_name_tag.text, '').strip()
                    first_name = first_name_tag.text.strip()
                else:
                    first_name = ''
                    last_name = last_name.strip()
                
                # Get nationality
                flag = cols[1].find('span', class_=lambda x: x and x.startswith('flag flag-'))
                nationality = flag['class'][1].replace('flag-', '').upper() if flag else ''
                
                # Format rider line with both first and last names
                rider_line = f"{number}. {first_name} {last_name}"
                if nationality:
                    rider_line += f" ({nationality})"
                if is_not_starting:
                    rider_line += " [NOT STARTING]"
                info += rider_line + "\n"
        
        return info
    except Exception as e:
        return f"Error retrieving start list for race ID {race_id}, year {year}: {str(e)}"

@mcp.tool(
    name="get_race_victory_table",
    description="""Get the all-time victory table for a cycling race.
    This tool provides a historical summary of the most successful riders in a specific race,
    showing the number of victories for each rider throughout the race's history.
    
    Note: If you don't know the race's ID, use the search_race tool first to find it by name.
    
    Example usage:
    - Get victory table for Tour de France (ID: 17)
    - Get victory table for Paris-Roubaix (ID: 30)
    
    Returns a formatted string with:
    - Race name
    - List of riders with the most victories
    - Number of victories for each rider
    - Years of victories where available"""
)
async def get_race_victory_table(race_id: int) -> str:
    """Get the all-time victory table for a cycling race.

    Args:
        race_id: The FirstCycling race ID (e.g., 17 for Tour de France)
    """
    try:
        # Create a race instance
        race = Race(race_id)
        
        # Get victory table
        victory_table = race.victory_table()
        
        # Build information string
        info = ""
        
        # Check if we can parse the data
        if not hasattr(victory_table, 'soup') or not victory_table.soup:
            return f"No victory table found for race ID {race_id}. This race ID may not exist."
        
        soup = victory_table.soup
        
        # Extract race name from title
        title = soup.find('title')
        race_name = title.text.split('|')[0].strip() if title and '|' in title.text else f"Race ID {race_id}"
        
        info += f"Victory Table for {race_name}:\n\n"
        
        # Check if we have results DataFrame
        if hasattr(victory_table, 'results_df') and not (victory_table.results_df is None or victory_table.results_df.empty):
            # Use standard parsing
            results_df = victory_table.results_df
            
            # Get top entries (limit to 20 for readability)
            results_df = results_df.head(20) if len(results_df) > 20 else results_df
            
            for i, (_, row) in enumerate(results_df.iterrows()):
                pos = i + 1
                rider = row.get('Rider', 'N/A')
                wins = row.get('Wins', 'N/A')
                years = row.get('Years', '')
                
                result_line = f"{pos}. {rider}: {wins} win"
                if wins != '1' and wins != 1:
                    result_line += "s"
                
                if years:
                    result_line += f" ({years})"
                
                info += result_line + "\n"
        else:
            # Direct HTML parsing
            # Find victory table
            victory_table_el = None
            tables = soup.find_all('table')
            
            for table in tables:
                headers = [th.text.strip() for th in table.find_all('th')]
                if any(header in ' '.join(headers) for header in ['Wins', 'Victory', 'Victories']):
                    victory_table_el = table
                    break
            
            if not victory_table_el:
                return f"Could not find victory table for race ID {race_id}."
            
            # Parse victory data
            rows = victory_table_el.find_all('tr')
            
            # Get column indices
            headers = [th.text.strip() for th in rows[0].find_all('th')]
            rider_idx = next((i for i, h in enumerate(headers) if "Rider" in h), 0)
            wins_idx = next((i for i, h in enumerate(headers) if "Wins" in h or "Victories" in h), 1)
            years_idx = next((i for i, h in enumerate(headers) if "Years" in h or "Year" in h), 2)
            
            # Skip header row and limit to 20 entries
            max_rows = min(21, len(rows))
            
            for i, row in enumerate(rows[1:max_rows]):
                cols = row.find_all('td')
                if len(cols) < 2:  # Ensure it's a data row
                    continue
                
                pos = i + 1
                
                # Rider name can be in a link
                rider_col = cols[rider_idx] if rider_idx < len(cols) else None
                rider = rider_col.text.strip() if rider_col else "N/A"
                
                wins = cols[wins_idx].text.strip() if wins_idx < len(cols) else "N/A"
                years = cols[years_idx].text.strip() if years_idx < len(cols) and years_idx < len(cols) else ""
                
                result_line = f"{pos}. {rider}: {wins} win"
                if wins != '1':
                    result_line += "s"
                
                if years:
                    result_line += f" ({years})"
                
                info += result_line + "\n"
            
            if len(rows) > 21:
                info += "...\n"
        
        return info
    except Exception as e:
        return f"Error retrieving victory table for race ID {race_id}: {str(e)}"

@mcp.tool(
    name="get_uci_rankings",
    description="""Get UCI rankings for riders, teams, or nations.
    This tool provides access to the UCI ranking data for professional cyclists, teams, or nations.
    Results can be filtered by ranking type, year, and category.
    
    Example usage:
    - Get World UCI rider rankings for 2023
    - Get Europe Tour UCI team rankings for 2022
    - Get UCI nation rankings for 2023 in the World category
    
    Returns a formatted string with:
    - Ranking list with positions and points
    - Filtered by specified categories
    - Organized in a readable format
    - Option to filter by country"""
)
async def get_uci_rankings(rank_type: str = "riders", category: str = "world", year: int = None, country_code: str = None, page_num: int = 1) -> str:
    """Get UCI rankings for riders, teams, or nations.

    Args:
        rank_type: The type of ranking to retrieve (riders, teams, or nations)
        category: The UCI ranking category (world, one-day, stage, europe, america, asia, africa, oceania)
        year: The year for the rankings (defaults to current year if None)
        country_code: Optional three-letter code to filter by country (e.g., "BEL" for Belgium)
        page_num: The page number for the results (default is 1)
    """
    try:
        # Map rank_type to h parameter
        h_params = {
            "riders": 1,
            "teams": 2,
            "nations": 3
        }
        
        # Map category to rank parameter
        rank_params = {
            "world": 1,
            "one-day": 2,
            "stage": 3,
            "africa": 4,
            "america": 5,
            "europe": 6,
            "asia": 7,
            "oceania": 8,
            "women": 99
        }
        
        # Get the parameter values
        h = h_params.get(rank_type.lower(), 1)  # Default to riders
        rank = rank_params.get(category.lower(), 1)  # Default to world
        
        # Create parameters dict
        params = {
            "h": h,
            "rank": rank,
            "page_num": page_num
        }
        
        # Add optional parameters
        if year:
            params["y"] = year
        
        if country_code:
            params["cnat"] = country_code.upper()
        
        # Get rankings
        rankings = Ranking(**params)
        
        # Build information string
        info = ""
        
        # Format title
        category_name = category.capitalize()
        rank_type_name = rank_type.capitalize()
        
        # Get year string
        year_str = str(year) if year else "Current"
        
        # Build title
        info += f"UCI {category_name} {rank_type_name} Rankings - {year_str}"
        if country_code:
            info += f" ({country_code.upper()})"
        
        info += f" - Page {page_num}:\n\n"
        
        # Check if we can parse the data
        if not hasattr(rankings, 'soup') or not rankings.soup:
            return f"No UCI rankings found for the specified parameters."
        
        soup = rankings.soup
        
        # Find rankings table
        rankings_table = None
        tables = soup.find_all('table')
        
        for table in tables:
            headers = [th.text.strip() for th in table.find_all('th')]
            if len(headers) >= 3 and ("Rank" in headers or "Pos" in headers or "Ranking" in headers):
                rankings_table = table
                break
        
        if not rankings_table:
            # Try to find any table with ranking-like structure
            for table in tables:
                rows = table.find_all('tr')
                if len(rows) >= 3:  # Header + at least 2 data rows
                    # Check if first cell might be a position/rank
                    first_row_cols = rows[1].find_all('td')
                    if len(first_row_cols) >= 3 and first_row_cols[0].text.strip().isdigit():
                        rankings_table = table
                        break
        
        if not rankings_table:
            return f"Could not find rankings table for the specified parameters."
        
        # Parse rankings data
        rows = rankings_table.find_all('tr')
        
        # Get headers to determine column positions
        headers = [th.text.strip() for th in rows[0].find_all('th')] if rows[0].find_all('th') else []
        
        # Find column indices based on rank type
        if rank_type.lower() == "riders":
            pos_idx = next((i for i, h in enumerate(headers) if "Rank" in h or "Pos" in h), 0)
            name_idx = next((i for i, h in enumerate(headers) if "Rider" in h or "Name" in h), 1)
            team_idx = next((i for i, h in enumerate(headers) if "Team" in h), 2)
            points_idx = next((i for i, h in enumerate(headers) if "Points" in h), 3)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                pos = cols[pos_idx].text.strip() if pos_idx < len(cols) else "N/A"
                name = cols[name_idx].text.strip() if name_idx < len(cols) else "N/A"
                team = cols[team_idx].text.strip() if team_idx < len(cols) and team_idx < len(cols) else "N/A"
                points = cols[points_idx].text.strip() if points_idx < len(cols) and points_idx < len(cols) else "N/A"
                
                info += f"{pos}. {name} ({team}): {points} pts\n"
        
        elif rank_type.lower() == "teams":
            pos_idx = next((i for i, h in enumerate(headers) if "Rank" in h or "Pos" in h), 0)
            team_idx = next((i for i, h in enumerate(headers) if "Team" in h), 1)
            points_idx = next((i for i, h in enumerate(headers) if "Points" in h), 2)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                pos = cols[pos_idx].text.strip() if pos_idx < len(cols) else "N/A"
                team = cols[team_idx].text.strip() if team_idx < len(cols) else "N/A"
                points = cols[points_idx].text.strip() if points_idx < len(cols) and points_idx < len(cols) else "N/A"
                
                info += f"{pos}. {team}: {points} pts\n"
        
        elif rank_type.lower() == "nations":
            pos_idx = next((i for i, h in enumerate(headers) if "Rank" in h or "Pos" in h), 0)
            nation_idx = next((i for i, h in enumerate(headers) if "Nation" in h or "Country" in h), 1)
            points_idx = next((i for i, h in enumerate(headers) if "Points" in h), 2)
            
            # Skip header row
            for row in rows[1:]:
                cols = row.find_all('td')
                if len(cols) < 3:  # Ensure it's a data row
                    continue
                
                pos = cols[pos_idx].text.strip() if pos_idx < len(cols) else "N/A"
                nation = cols[nation_idx].text.strip() if nation_idx < len(cols) else "N/A"
                points = cols[points_idx].text.strip() if points_idx < len(cols) and points_idx < len(cols) else "N/A"
                
                info += f"{pos}. {nation}: {points} pts\n"
        
        # Include pagination info if available
        pagination = soup.find('div', class_='pagination')
        if pagination:
            info += "\n"
            # Find the last page number if available
            last_page_link = pagination.find_all('a')[-1] if pagination.find_all('a') else None
            if last_page_link and last_page_link.text.strip().isdigit():
                total_pages = int(last_page_link.text.strip())
                info += f"Page {page_num} of {total_pages}\n"
        
        if info.count('\n') <= 2:  # Only contains title and maybe pagination info
            return f"No rankings data found for the specified parameters."
            
        return info
    except Exception as e:
        return f"Error retrieving UCI rankings: {str(e)}"

if __name__ == "__main__":
    # Initialize and run the server
    mcp.run(transport='stdio')