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


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

ddg_tool = DuckDuckGoSearchTool()  # Instantiate the search tool

@tool
def web_search(query: str) -> str:
    """Performs a DuckDuckGo web search and returns results.

    Args:
        query: The search query string.

    Returns:
        A string containing search results.
    """
    return ddg_tool.run(query)  # Use .run() method to execute search

# Load sentiment analysis model
sentiment_pipeline = pipeline("sentiment-analysis")

@tool
def analyze_sentiment(text: str) -> str:
    """Analyzes the sentiment of a given text.

    Args:
        text: A string containing the text to analyze.

    Returns:
        A string indicating whether the sentiment is Positive, Neutral, or Negative.
    """
    try:
        result = sentiment_pipeline(text)[0]  # Get sentiment result
        sentiment = result["label"]
        score = result["score"]

        # Convert model labels to more user-friendly labels
        if sentiment.lower() == "positive":
            return f"Positive sentiment with confidence {score:.2f} 🎉"
        elif sentiment.lower() == "negative":
            return f"Negative sentiment with confidence {score:.2f} 😞"
        else:
            return f"Neutral sentiment with confidence {score:.2f} 🤔"

    except Exception as e:
        return f"Error analyzing sentiment: {str(e)}"

@tool
def futurizer_9000(topic: str) -> str:
    """Predicts the future based on current trends and news.

    Args:
        topic: The subject for future prediction (e.g., "AI in 2030", "The Future of Space Travel").

    Returns:
        A wild, speculative but semi-informed prediction.
    """
    try:
        # Step 1: Search the web for recent news
        search_results = ddg_tool(topic)
        if not search_results:
            return f"Could not find any recent news on {topic}."

        # Step 2: Analyze sentiment of the top result
        sentiment_result = sentiment_pipeline(search_results[:512])[0]  # Limit to avoid overflow
        sentiment = sentiment_result["label"]
        confidence = sentiment_result["score"]

        # Step 3: Generate a wild future prediction
        wild_predictions = {
            "Positive": [
                f"In {random.randint(2030, 2070)}, {topic} will revolutionize the world in ways we never imagined! 🚀",
                f"Experts believe {topic} will create millions of jobs and push humanity to new heights. 🌍",
                f"By {random.randint(2035, 2080)}, {topic} will be an integral part of daily life, making everything more efficient and exciting. 🎉"
            ],
            "Negative": [
                f"Warning! By {random.randint(2040, 2099)}, {topic} might lead to catastrophic consequences! 😱",
                f"Experts predict {topic} could spiral out of control, causing global instability by {random.randint(2035, 2100)}. ⚠️",
                f"Brace yourself! The rise of {topic} may result in mass unemployment and social upheaval by {random.randint(2045, 2105)}. 😨"
            ],
            "Neutral": [
                f"In {random.randint(2035, 2085)}, {topic} will likely evolve in unpredictable ways, balancing both pros and cons. 🤔",
                f"Futurists believe {topic} will be a slow but steady change, impacting society gradually over time. ⏳",
                f"By {random.randint(2040, 2090)}, {topic} may be seen as a regular part of life, neither groundbreaking nor catastrophic. 🔍"
            ]
        }

        # Choose a prediction based on sentiment
        prediction = random.choice(wild_predictions.get(sentiment, wild_predictions["Neutral"]))

        return f"🌟 **FUTURE PREDICTION FOR {topic.upper()}** 🌟\n\n" \
               f"📌 Recent sentiment: **{sentiment}** (Confidence: {confidence:.2f})\n" \
               f"📰 Based on recent news: **{search_results[:200]}...**\n\n" \
               f"🔮 **Prediction:** {prediction}"

    except Exception as e:
        return f"Error predicting the future for {topic}: {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,
)


# 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, image_generation_tool, web_search,analyze_sentiment, futurizer_9000], ## 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()