from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
import datetime
import requests
import pytz
import yaml
import WebSearchTool
from tools.final_answer import FinalAnswerTool
from ip2geotools.databases.noncommercial import DbIpCity
from bs4 import BeautifulSoup
import urllib as ur
import tkinter as tk
from tkinter.messagebox import *
import json
from PIL import ImageTk

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 important 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

@tool
def get_location_tool(ip: str):
    response = DbIpCity.get(ip, api_key='free')

    return {
        'city': response.city,
        'region': response.region,
        'country': response.country,
        'latitude': response.latitude,
        'longitude': response.longitude
    }

    """
    This is a tool that gets the exact location of a user including city, region, country, latitude, and longitude.
    Args: 
        ip: A string representing a valid ip address (e.g., '192.168.10.1')
    
    Returns: ip address, city, region, country, and geo coordinates
    """
        
response = DbIpCity.get('YOUR_IP_ADDRESS')  # Replace with the actual IP address
location = get_location('ip_address')
print(location)


@tool
def get_current_time_in_timezone(timezone: 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')
    
    Returns: The current local time in the following format ("%Y-%m-%d %H:%M:%S")
    """
    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()

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

@tool
def get_weather_data(city: str):
    
    """
    Returns weather data for a given city.
    Args:
        city: The name of the city (e.g., New York, London, Tokyo)
    Returns:
        A dictionary containing weather data
    """
    # Get weather for multiple cities
    cities = ["Tokyo", "New York", "London"]
    data = {}

    for city in cities:
        data[city] = get_weather_data(city)
    
    # Calculate average temperatures
    avg_temps = {city: sum(info["temperatures"])/len(info["temperatures"]) 
                for city, info in data.items()}
    
    # Find the warmest city
    warmest_city = max(avg_temps, key=avg_temps.get)
    print(f"The warmest city is {warmest_city} with an average of {avg_temps[warmest_city]:.1f}°C")  

 
@tool
def hotel_recommendation_tool(city: str, price: str) -> str:
    """
    This is a hotel recommendation tool that web scrapes foursquare.com and yelp.com for hotel ratings, user comments, and hotel information.
    Args:
        city: A string representing a valid city (e.g., 'Dubai, Singapore')
        price: A string representing a valid price for the hotel rooms (e.g., '$160/night, $100/day')

    Returns:
        A hotel name in a particular city with its pricing and rating information
    """
    
    if price != "-":
        response = ur.request.urlopen('https://foursquare.com/explore?mode=url&near=' + city + '&price=' + price + '&q=Resturant')
    else:
        response = ur.request.urlopen('https://foursquare.com/explore?mode=url&near=' + city + '&q=Resturant')
        
    html = response.read()
    soup = BeautifulSoup(html, 'html.parser')
    name = []
    rate = []
    add = []
    y = """<li class="card singleRecommendation hasPhoto\""""
    
    for link in soup.find_all('li'):
        if y in str(link):
            name.append(link.find('div', {"class":"venueName"}))
        if link.find('div', {"class":"venueScore positive"}) != None:
            rate.append(link.find('div', {"class":"venueScorepositive"}))
        elif link.find('div', {"class":"venueScore neutral"}) != None:
            rate.append(link.find('div', {"class":"venueScoreneutral"}))
        else:
            rate.append(link.find('div', {"class":"venueScoreunknown"}))
    
    rate1 = []
    
    for x in rate:
        if x != None:
            rate1.append(x.string.encode("utf-8"))
        else:
            rate1.append("?")
    
    name1 = []
    for x in name:
        name1.append(x.a.string.encode("utf-8"))
        
    name_rate = []
    for i in range(0, len(name1)):
        name_rate.append((name1[i], rate1[i]))
        
    return name_rate


def yelp(city, price):
    name_rate = []
    count = 0
    while (count < 30):
        if price != "-":
            response = ur.request.urlopen('https://www.yelp.com/search?find_desc=Restaurants&find_loc=' + city + '&start=' + str(count) + '&ed_attrs=RestaurantsPriceRange2.' + price)
        else:
            response = ur.request.urlopen('https://www.yelp.com/search?find_desc=Restaurants&find_loc=' + city + '&start=' + str(count))
        
        html = response.read()
        count += 10
        soup = BeautifulSoup(html, 'html.parser')
        
        y = """<li class="regular-search-result">"""
        name = []
        rate = []
        name1 = []
        rate1 = []
        
        for link in soup.find_all('li'):
            if (y in str(link)):
                name.append(link.find('span', {"class":"indexed-bizname"}))
                rate.append(link.find('img', {"class":"offscreen"}))
                
        for i in name:
            name1.append(i.span.string.encode("utf-8"))
            
        for i in rate:
            try:
                s = str(i['alt'])
                rate1.append(float(s[0:3]))
            except:
                rate1.append("?")
        
        for i in range(0, len(name1)):
            name_rate.append((name1[i], rate1[i]))
    
    return name_rate


root=tk.Tk()
root.geometry("645x660")
root.configure(bg='#211C5F')
root.title("Scraping Recommender")

def locate():
    send_url = 'http://freegeoip.net/json'
    r = requests.get(send_url)
    j = json.loads(r.text)
    lat = j['latitude']
    lon = j['longitude']
    e1.delete(0,tk.END)
    city=str(lat)+" "+str(lon)
    e1.insert(tk.END,"Current Location")
    return city

def get():
    city=e1.get()
    if(city=="Current Location"):
        city=locate()
    price=e2.get()
    if city=="":
        showerror(title="Empty Field",message="Please Enter a City!")
        return
    l=["1","2","3","4","-"]
    if price not in l:
        showerror(title="Please Wait",message="Please Enter Correct Price Range!")
        return

@tool
def SearchTool(DuckDuckGoSearchTool): query
"""
    name = "web_search"
    description = "Performs a web search for a query and returns a list of the top search results formatted as markdown with page titles and urls."
    inputs = {"query": {"type": "string", "description": "The search query to perform."}}
    output_type = "string"
"""
    
search_tool = DuckDuckGoSearchTool()
agent = CodeAgent(tools=[search_tool], model=model, add_base_tools=False, verbosity_level=2)

GradioUI(agent).launch()