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

# Tool for standard BTC dominance
@tool
def get_standard_btc_dominance() -> str:
    """A tool that calculates standard BTC Dominance as (BTC market cap / Total crypto market cap) * 100.
    Returns:
        The standard BTC Dominance percentage as a string.
    """
    try:
        url = "https://api.coingecko.com/api/v3/global"
        response = requests.get(url)
        if response.status_code != 200:
            return f"Error: API returned status code {response.status_code}"
        data = response.json()
        
        btc_market_cap = data['data']['market_cap_percentage']['btc']
        total_market_cap = data['data']['total_market_cap']['usd']
        
        dominance = (btc_market_cap / 100) * 100
        return f"Standard BTC Dominance (BTC mc / Total crypto mc): {dominance:.2f}%"
    except Exception as e:
        return f"Error calculating standard BTC Dominance: {str(e)}"

# Tool for BTC dominance excluding stablecoins
@tool
def get_btc_dominance_excluding_stablecoins() -> str:
    """A tool that calculates BTC Dominance excluding stablecoins as (BTC market cap / (Total market cap - Stablecoins market cap)) * 100.
    Stablecoins excluded: USDT, USDC, DAI, BUSD.
    Returns:
        The BTC Dominance percentage excluding stablecoins as a string.
    """
    try:
        url_global = "https://api.coingecko.com/api/v3/global"
        response_global = requests.get(url_global)
        if response_global.status_code != 200:
            return f"Error: Global API returned status code {response_global.status_code}"
        global_data = response_global.json()

        url_coins = "https://api.coingecko.com/api/v3/coins/markets"
        params = {
            "vs_currency": "usd",
            "order": "market_cap_desc",
            "per_page": 200,
            "page": 1,
            "sparkline": False
        }
        response_coins = requests.get(url_coins, params=params)
        if response_coins.status_code != 200:
            return f"Error: Coins API returned status code {response_coins.status_code}"
        coins_data = response_coins.json()

        btc_data = next((coin for coin in coins_data if coin['id'] == 'bitcoin'), None)
        if not btc_data:
            return "Error: Bitcoin data not found."
        btc_market_cap = btc_data['market_cap']

        total_market_cap = global_data['data']['total_market_cap']['usd']
        stablecoin_ids = ['tether', 'usd-coin', 'dai', 'binance-usd']
        stablecoin_market_caps = 0
        for coin in coins_data:
            if coin['id'] in stablecoin_ids:
                stablecoin_market_caps += coin['market_cap']

        adjusted_market_cap = total_market_cap - stablecoin_market_caps
        dominance = (btc_market_cap / adjusted_market_cap) * 100
        return f"BTC Dominance excluding stablecoins (USDT, USDC, DAI, BUSD): {dominance:.2f}%"
    except Exception as e:
        return f"Error calculating BTC Dominance excluding stablecoins: {str(e)}"

# Tool for standard ETH dominance
@tool
def get_standard_eth_dominance() -> str:
    """A tool that calculates standard ETH Dominance as (ETH market cap / Total crypto market cap) * 100.
    Returns:
        The standard ETH Dominance percentage as a string.
    """
    try:
        url = "https://api.coingecko.com/api/v3/global"
        response = requests.get(url)
        if response.status_code != 200:
            return f"Error: API returned status code {response.status_code}"
        data = response.json()
        
        eth_market_cap = data['data']['market_cap_percentage']['eth']
        total_market_cap = data['data']['total_market_cap']['usd']
        
        dominance = (eth_market_cap / 100) * 100
        return f"Standard ETH Dominance (ETH mc / Total crypto mc): {dominance:.2f}%"
    except Exception as e:
        return f"Error calculating standard ETH Dominance: {str(e)}"

# Model setup
model = HfApiModel(
    max_tokens=2096,
    temperature=0.5,
    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 setup
agent = CodeAgent(
    model=model,
    tools=[get_standard_btc_dominance, get_btc_dominance_excluding_stablecoins, get_standard_eth_dominance],
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)

# Example usage
if __name__ == "__main__":
    print(get_standard_eth_dominance())  # Corrected to use the function

GradioUI(agent).launch()