from smolagents import DuckDuckGoSearchTool
import random
from huggingface_hub import list_models
import pandas as pd
import numpy as np
from typing import TypedDict, Annotated, Union, Dict, Any
import base64
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
import requests
import os
import subprocess
import tempfile
import openai

def download_file(task_id: str, file_name: str) -> str:
    """Downloads a file associated with a task_id and returns the local file path"""
    try:
        # Create downloads directory if it doesn't exist
        os.makedirs("downloads", exist_ok=True)
        
        # Download the file
        file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
        response = requests.get(file_url)
        response.raise_for_status()
        
        # Save the file locally
        local_path = os.path.join("downloads", file_name)
        with open(local_path, "wb") as f:
            f.write(response.content)
            
        return local_path
        
    except Exception as e:
        return f"Error downloading file: {str(e)}"

def get_hub_stats(author: str) -> str:
    """Fetches the most downloaded model from a specific author on the Hugging Face Hub."""
    try:
        # List models from the specified author, sorted by downloads
        models = list(list_models(author=author, sort="downloads", direction=-1, limit=1))

        if models:
            model = models[0]
            return f"The most downloaded model by {author} is {model.id} with {model.downloads:,} downloads."
        else:
            return f"No models found for author {author}."
    except Exception as e:
        return f"Error fetching models for {author}: {str(e)}"


def get_image_mime_type(image_path: str) -> str:
    """Detect the MIME type of an image file"""
    import os
    _, ext = os.path.splitext(image_path.lower())
    
    mime_types = {
        '.jpg': 'image/jpeg',
        '.jpeg': 'image/jpeg', 
        '.png': 'image/png',
        '.gif': 'image/gif',
        '.bmp': 'image/bmp',
        '.webp': 'image/webp'
    }
    
    return mime_types.get(ext, 'image/jpeg')  # Default to jpeg if unknown

def encode_image_to_base64(image_path: str) -> tuple[str, str]:
    """Convert image file to base64 string and return with MIME type"""
    try:
        with open(image_path, "rb") as image_file:
            base64_data = base64.b64encode(image_file.read()).decode('utf-8')
            mime_type = get_image_mime_type(image_path)
            return base64_data, mime_type
    except Exception as e:
        raise Exception(f"Error encoding image: {e}")

def analyze_image(image_path: str, question: str = "What do you see in this image?") -> str:
    """Analyze an image using LangChain's ChatOpenAI with vision"""
    try:
        # Create vision-capable LLM
        # vision_llm = ChatOpenAI(model="gpt-4o", max_tokens=1000)
        # vision_llm = ChatOpenAI(model="gpt-4.1", max_tokens=1000)
        vision_llm = ChatOpenAI(model="gpt-4.1")
        
        # Encode the image and get correct MIME type
        base64_image, mime_type = encode_image_to_base64(image_path)
        
        # Create message with image using correct MIME type
        message = HumanMessage(
            content=[
                {"type": "text", "text": question},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{mime_type};base64,{base64_image}",
                        "detail": "high"
                    }
                }
            ]
        )
        
        # Get response
        response = vision_llm.invoke([message])
        return response.content
        
    except Exception as e:
        return f"Error analyzing image: {e}"

def read_excel_file(file_path: str) -> Dict[str, Any]:
    """
    Reads an Excel file and returns structured information about its contents
    
    Args:
        file_path: Path to the Excel file
        
    Returns:
        Dictionary containing file analysis
    """
    try:
        # Read all sheets
        excel_file = pd.ExcelFile(file_path)
        sheet_names = excel_file.sheet_names
        
        result = {
            "file_path": file_path,
            "sheet_names": sheet_names,
            "sheets_data": {},
            "summary": {}
        }
        
        for sheet_name in sheet_names:
            df = pd.read_excel(file_path, sheet_name=sheet_name)
            
            # Basic info about the sheet
            sheet_info = {
                "shape": df.shape,
                "columns": df.columns.tolist(),
                "dtypes": df.dtypes.to_dict(),
                "data": df,
                "sample_data": df.head().to_dict(),
                "numeric_columns": df.select_dtypes(include=[np.number]).columns.tolist(),
                "text_columns": df.select_dtypes(include=['object']).columns.tolist()
            }
            
            result["sheets_data"][sheet_name] = sheet_info
        
        return result
        
    except Exception as e:
        return {"error": f"Failed to read Excel file: {str(e)}"}

def execute_python_code(file_path: str, timeout: int = 60) -> str:
    """Execute Python code safely with subprocess"""
    try:
        # Check if file exists, if not try common locations
        if not os.path.exists(file_path):
            # Try in downloads directory
            alt_path = os.path.join("downloads", os.path.basename(file_path))
            if os.path.exists(alt_path):
                file_path = alt_path
            else:
                return f"Error: File not found at {file_path} or {alt_path}"
        
        # Ensure we have absolute path
        file_path = os.path.abspath(file_path)
        
        # Run in isolated subprocess with timeout
        result = subprocess.run(
            ['python', file_path],
            capture_output=True,
            text=True,
            timeout=timeout,
            cwd=os.path.dirname(file_path)  # Run in the file's directory
        )
        
        if result.returncode == 0:
            return result.stdout.strip()
        else:
            return f"Error: {result.stderr}"
            
    except subprocess.TimeoutExpired:
        return "Error: Code execution timed out"
    except Exception as e:
        return f"Error executing code: {str(e)}"

def transcribe_audio(file_path: str) -> str:
    """Transcribe audio file using OpenAI Whisper"""
    try:
        with open(file_path, "rb") as audio_file:
            transcript = openai.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file
            )
        return transcript.text
    except Exception as e:
        return f"Error transcribing audio: {str(e)}"