from smolagents import CodeAgent,HfApiModel,load_tool,tool
from smolagents import CodeAgent,DuckDuckGoSearchTool,HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool
from tools.visit_webpage import VisitWebpageTool
from typing import List, Dict
# from tools.web_search import DuckDuckGoSearchTool

from Gradio_UI import GradioUI

ddg = DuckDuckGoSearchTool(max_results=5)

@tool
def github_issues(repo: str, state: str = "open", limit: int = 5) -> List[Dict]:
    """
    Fetch recent issues from a public GitHub repo.

    Args:
        repo: GitHub repo in the form "owner/name" (e.g. "facebook/react").
        state: "open", "closed", or "all".
        limit: Maximum number of issues to return (max GitHub default = 30).

    Returns:
        A list of issues, each as a dict with keys:
        - number: int
        - title: str
        - url: str
        - state: str
        - labels: List[str]
    """
    url = f"https://api.github.com/repos/{repo}/issues"
    params = {"state": state, "per_page": min(limit, 30)}

    try:
        res = requests.get(url, params=params, timeout=8)
        res.raise_for_status()
        data = res.json()
    except Exception as e:
        return f"❌ GitHub request error: {e}"

    issues_list: List[Dict] = []

    for issue in data:
        # Skip PRs (GitHub includes PRs in /issues endpoint)
        if "pull_request" in issue:
            continue
    
        number = issue.get("number")
        title = (issue.get("title") or "No title").strip()
        html_url = issue.get("html_url")
        state_ = issue.get("state")
        labels = [lbl.get("name") for lbl in issue.get("labels", [])]
    
        issues_list.append(
            {
                "number": number,
                "title": title,
                "url": html_url,
                "state": state_,
                "labels": labels,
            }
        )
    
        if len(issues_list) >= limit:
            break
    
    return issues_list

@tool
def web_search(query:str)-> str:
    """A tool that runs a DuckDuckGo search and returns a formatted result.
    Args:
        query: A string representing the query to search for.
    """
    try:
        results = ddg(query)
        return results
    except Exception as e:
        return f"Error while searching: {str(e)}"

@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)}"


final_answer = FinalAnswerTool()
# web_search = DuckDuckGoSearchTool()
visit_webpage = VisitWebpageTool()

# 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,
)


# 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_current_time_in_timezone, web_search, visit_webpage, image_generation_tool, github_issues], ## 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()