from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool

from Gradio_UI import GradioUI

# Below is an example of a tool that does nothing. Amaze us with your creativity !
@tool
def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
    #Keep this format for the description / args / args description but feel free to modify the tool
    """A tool that does nothing yet 
    Args:
        arg1: the first argument
        arg2: the second argument
    """
    return "What magic will you build ?"

@tool
def get_current_time_in_timezone(timezone: str) -> str:
    """A tool that fetches the current local time in a specified timezone.
    Args:
        timezone: A string representing a valid timezone (e.g., 'America/New_York').
    """
    try:
        # Create timezone object
        tz = pytz.timezone(timezone)
        # Get current time in that timezone
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        return f"The current local time in {timezone} is: {local_time}"
    except Exception as e:
        return f"Error fetching time for timezone '{timezone}': {str(e)}"

@tool
def get_movie_recommendations(genre: str = "", year: str = "", actor: str = "") -> str:
    """Obtém recomendações de filmes com base nos critérios fornecidos
    Args:
        genre: Gênero do filme (ex: ação, comédia, drama)
        year: Ano de lançamento ou década (ex: 2023, 1990s)
        actor: Nome de um ator ou atriz presente no filme
    """
    try:
        # Para este exemplo, usaremos a API pública do The Movie Database (TMDb)
        # Você precisaria registrar-se para obter uma chave de API gratuita
        api_key = "de60d56926e172819c78eaf039c853be"  # Substitua pela sua chave
        base_url = "https://api.themoviedb.org/3"
        
        # Construir os parâmetros de consulta
        params = {
            "api_key": api_key,
            "language": "pt-BR",
            "sort_by": "popularity.desc",
            "include_adult": "false",
            "page": 1
        }
        
        # Adicionar filtragens com base nos argumentos fornecidos
        if genre:
            # Converter nome do gênero para ID - simplificado para o exemplo
            genre_map = {"ação": 28, "comédia": 35, "drama": 18, "ficção científica": 878}
            genre_id = genre_map.get(genre.lower())
            if genre_id:
                params["with_genres"] = genre_id
                
        if year:
            if year.endswith("s"):  # Década como "1990s"
                decade = year[:-1]  # Remove o 's'
                params["primary_release_date.gte"] = f"{decade}-01-01"
                params["primary_release_date.lte"] = f"{int(decade) + 9}-12-31"
            else:  # Ano específico
                params["primary_release_year"] = year
                
        if actor:
            # Para simplicidade, assumimos que fornecemos o ID do ator
            # Em uma implementação real, você faria uma busca pelo nome do ator primeiro
            actor_search_url = f"{base_url}/search/person"
            actor_params = params.copy()
            actor_params["query"] = actor
            actor_response = requests.get(actor_search_url, params=actor_params)
            actor_data = actor_response.json()
            
            if actor_data.get("results") and len(actor_data["results"]) > 0:
                actor_id = actor_data["results"][0]["id"]
                params["with_cast"] = actor_id
        
        # Fazer a requisição à API
        endpoint = f"{base_url}/discover/movie"
        response = requests.get(endpoint, params=params)
        data = response.json()
        
        # Processar e formatar os resultados
        if not data.get("results"):
            return "Nenhum filme encontrado com esses critérios."
            
        movies = data["results"][:5]  # Limitar a 5 recomendações
        
        recommendations = f"Aqui estão algumas recomendações de filmes para você:\n\n"
        for i, movie in enumerate(movies, 1):
            title = movie.get("title", "Título desconhecido")
            release_date = movie.get("release_date", "Data desconhecida")
            if release_date:
                release_year = release_date.split("-")[0]
            else:
                release_year = "Ano desconhecido"
                
            rating = movie.get("vote_average", "Sem avaliação")
            overview = movie.get("overview", "Sem descrição disponível.")
            
            recommendations += f"{i}. {title} ({release_year}) - {rating}/10\n"
            recommendations += f"   {overview[:150]}...\n\n"
            
        return recommendations
            
    except Exception as e:
        return f"Erro ao buscar recomendações de filmes: {str(e)}"


final_answer = FinalAnswerTool()

# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 

model = HfApiModel(
max_tokens=2096,
temperature=0.5,
 # model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud',
custom_role_conversions=None,
)


# Import tool from Hub
image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)
    
agent = CodeAgent(
    model=model,
    tools=[final_answer,get_movie_recommendations,get_current_time_in_timezone], ## add your tools here (don't remove final answer)
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)


GradioUI(agent).launch()