from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
import requests
import yaml
from tools.final_answer import FinalAnswerTool
import gradio as gr
from difflib import get_close_matches

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

##############
@tool
def get_game_of_thrones_character_info(character_name: str) -> str:
    """Una herramienta que obtiene información detallada sobre un personaje de Juego de Tronos.
    Args:
        character_name: El nombre del personaje (por ejemplo, 'Jon Snow').
    Returns:
        Un string con la información detallada del personaje.
    """
    base_url = "https://anapioficeandfire.com/api/characters"
    
    try:
        # Hacer la solicitud a la API para buscar el personaje
        params = {"name": character_name}
        response = requests.get(base_url, params=params)
        response.raise_for_status()  # Lanza una excepción si hay un error HTTP
        characters = response.json()
        
        if not characters:
            # Si no se encuentra el personaje, buscar nombres similares
            all_characters_response = requests.get(base_url, params={"pageSize": 1000})
            all_characters_response.raise_for_status()
            all_characters = all_characters_response.json()
            all_names = [char.get("name", "") for char in all_characters if char.get("name")]
            
            # Buscar nombres similares
            close_matches = get_close_matches(character_name, all_names, n=2, cutoff=0.5)
            if close_matches:
                suggestions = "\n- " + "\n- ".join(close_matches)
                return f"No se encontró información para el personaje: {character_name}.\n\n¿Quizás quisiste decir alguno de estos?\n{suggestions}"
            else:
                return f"No se encontró información para el personaje: {character_name}."
        
        # Tomar el primer resultado (puede haber varios con el mismo nombre)
        character = characters[0]
        
        # Extraer información relevante del personaje
        name = character.get("name", "Desconocido")
        gender = "Masculino" if character.get("gender", "").lower() == "male" else "Femenino"
        culture = character.get("culture", "Desconocido")
        born = character.get("born", "Desconocido")
        died = character.get("died", "Aún vivo")
        titles = ", ".join(character.get("titles", [])) if character.get("titles") else "Ninguno"
        aliases = ", ".join(character.get("aliases", [])) if character.get("aliases") else "Ninguno"
        
        # Obtener información de la casa (si está disponible)
        houses = []
        if "allegiances" in character:
            for house_url in character["allegiances"]:
                house_response = requests.get(house_url)
                house_response.raise_for_status()
                house_data = house_response.json()
                house_name = house_data.get("name", "Desconocido")
                houses.append(house_name)
        
        # Obtener información de los libros en los que aparece
        books = []
        if "books" in character:
            for book_url in character["books"]:
                book_response = requests.get(book_url)
                book_response.raise_for_status()
                book_data = book_response.json()
                book_name = book_data.get("name", "Desconocido")
                books.append(book_name)
        
        # Formatear la respuesta en español
        result = f"Información sobre {name}\n\n"
        result += f"- Género: {gender}\n"
        result += f"- Cultura: {culture}\n"
        result += f"- Nacimiento: {born}\n"
        result += f"- Muerte: {died}\n"
        result += f"- Títulos: {titles}\n"
        result += f"- Alias: {aliases}\n"
        if houses:
            result += f"- Casa(s): {', '.join(houses)}\n"
        else:
            result += "- Casa(s): Ninguna o desconocida\n"
        if books:
            result += f"- Libros en los que aparece: {', '.join(books)}\n"
        else:
            result += "- Libros en los que aparece: Ninguno o desconocido\n"
        
        return result
    
    except Exception as e:
        return f"Error al obtener información del personaje: {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
    custom_role_conversions=None,
)

with open("prompts.yaml", 'r') as stream:
    prompt_templates = yaml.safe_load(stream)
    
agent = CodeAgent(
    model=model,
    tools=[final_answer, get_game_of_thrones_character_info],  # 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
)

##############
def display_character_info(character_name):
    result = get_game_of_thrones_character_info(character_name)
    return result

# Crear una interfaz de Gradio
interface = gr.Interface(
    fn=display_character_info,
    inputs=gr.Textbox(label="Nombre del personaje", placeholder="Ejemplo: Jon Snow"),
    outputs=gr.Textbox(label="Información del personaje"),  # Sin el parámetro markdown
    title="Información de Personajes de Juego de Tronos",
    description="Ingresa el nombre de un personaje de Juego de Tronos para obtener información detallada.",
    examples=["Jon Snow", "Daenerys Targaryen", "Tyrion Lannister", "Viserys Targaryen", "Arya Stark", "Sansa Stark", "Sandor Clegane", "Rhaenyra Targaryen", 
              "Daemon Targaryen", "Aemond Targaryen", "Cersei Lannister", "Bran Stark"],
    theme="soft"
)

interface.launch()