# Dependency Installation
# Install necessary libraries
!pip install requests
!pip install pandas
!pip install numpy
!pip install matplotlib
!pip install seaborn

# Library Imports
import requests
import json
import logging
import time
import random
from collections import deque
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from typing import Dict, Any, List, Tuple

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def create_alert_system_state(max_retries: int = 5, base_backoff_sec: int = 1) -> Dict[str, Any]:
    """
    Initializes the state dictionary for the alert system.

    Parameters
    ----------
    max_retries : int, optional
        The maximum number of times to retry sending an alert, defaults to 5.
    base_backoff_sec : int, optional
        The base number of seconds for exponential backoff, defaults to 1.

    Returns
    -------
    dict
        A dictionary containing the initial state of the alert system.
    """
    state = {
        'max_retries': max_retries,
        'base_backoff_sec': base_backoff_sec,
        'sent_alerts_count': 0,
        'failed_alerts_count': 0
    }
    logger.info(f"Alert system state initialized with max_retries={max_retries}, base_backoff_sec={base_backoff_sec}")
    return state

def send_discord_webhook_message(state: Dict[str, Any], webhook_url: str, message_content: str) -> bool:
    """
    Sends a message to a Discord webhook URL with exponential backoff and jitter.

    Parameters
    ----------
    state : dict
        Current state dictionary with 'max_retries' and 'base_backoff_sec'.
    webhook_url : str
        The Discord webhook URL.
    message_content : str
        The text content of the message to be sent.

    Returns
    -------
    bool
        True if the message was sent successfully, False otherwise.
    """
    payload = {
        'content': message_content
    }
    headers = {
        'Content-Type': 'application/json'
    }

    for i in range(state['max_retries']):
        try:
            response = requests.post(webhook_url, data=json.dumps(payload), headers=headers, timeout=10)
            response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
            logger.info(f"Alert successfully sent to Discord on attempt {i+1}.")
            state['sent_alerts_count'] += 1
            return True
        except requests.exceptions.RequestException as e:
            wait_time = state['base_backoff_sec'] * (2 ** i) + random.uniform(0, 1)
            logger.warning(f"Attempt {i+1} failed to send alert: {e}. Retrying in {wait_time:.2f} seconds...")
            time.sleep(wait_time)

    logger.error(f"Failed to send alert to Discord after {state['max_retries']} attempts.")
    state['failed_alerts_count'] += 1
    return False

def create_trade_data_state(num_data_points: int = 100, initial_price: float = 100.0, volatility: float = 0.5) -> Dict[str, Any]:
    """
    Initializes a dictionary with simulated trade data.

    Generates a synthetic price series for demonstration.

    Parameters
    ----------
    num_data_points : int, optional
        Number of simulated price data points, defaults to 100.
    initial_price : float, optional
        Starting price for the simulated series, defaults to 100.0.
    volatility : float, optional
        Standard deviation of daily price changes, defaults to 0.5.

    Returns
    -------
    dict
        A dictionary containing the simulated price data and parameters.
    """
    prices = [initial_price]
    for _ in range(1, num_data_points):
        change = np.random.normal(0, volatility)
        prices.append(prices[-1] + change)

    df = pd.DataFrame({
        'timestamp': pd.to_datetime(pd.date_range(start='2023-01-01', periods=num_data_points, freq='H')),
        'price': prices
    })

    state = {
        'trade_data': df,
        'num_data_points': num_data_points,
        'initial_price': initial_price,
        'volatility': volatility
    }
    logger.info(f"Simulated trade data generated with {num_data_points} points.")
    return state

def generate_trade_signal(state: Dict[str, Any], price: float) -> Tuple[str, str]:
    """
    Simulates a trade signal (BUY, SELL, HOLD) for demonstration.

    Parameters
    ----------
    state : dict
        Current state dictionary (not used in this simplified signal generation).
    price : float
        The current price, used for context in the alert message.

    Returns
    -------
    Tuple[str, str]
        A tuple containing the signal type and a descriptive message.
    """
    signal_type = random.choice(['BUY', 'SELL', 'HOLD'])
    message = f"Simulated signal: {signal_type} at price ${price:.2f}"
    logger.debug(f"Generated signal: {signal_type} for price {price:.2f}")
    return signal_type, message

def summarize_alert_metrics(state: Dict[str, Any]) -> Dict[str, Any]:
    """
    Summarizes the alert sending metrics from the alert system state.

    Parameters
    ----------
    state : dict
        Current state dictionary with 'sent_alerts_count' and 'failed_alerts_count'.

    Returns
    -------
    dict
        A dictionary containing summary metrics.
    """
    total_attempts = state['sent_alerts_count'] + state['failed_alerts_count']
    success_rate = (state['sent_alerts_count'] / total_attempts) * 100 if total_attempts > 0 else 0

    metrics = {
        'total_alert_attempts': total_attempts,
        'successful_alerts': state['sent_alerts_count'],
        'failed_alerts': state['failed_alerts_count'],
        'success_rate_percent': f"{success_rate:.2f}%"
    }
    logger.info(f"Alert metrics summarized: {metrics}")
    return metrics

# @title Discord Webhook Configuration (Run this cell to set up your webhook)
# Replace with your actual Discord Webhook URL
DISCORD_WEBHOOK_URL = "ENTER DISCORD URL" # @param {type:"string"}

if DISCORD_WEBHOOK_URL == "ENTER DISCORD URL" or not DISCORD_WEBHOOK_URL.startswith('https://discord.com/api/webhooks'):
    logger.warning("Please update DISCORD_WEBHOOK_URL with a valid Discord webhook URL to receive alerts.")
else:
    logger.info("Discord Webhook URL configured.")

# Initialize states
alert_system_state = create_alert_system_state(max_retries=3, base_backoff_sec=0.5)
trade_data_state = create_trade_data_state(num_data_points=20, initial_price=100.0, volatility=0.8)

df_trades = trade_data_state['trade_data'].copy()
df_trades['signal'] = 'HOLD'
df_trades['alert_message'] = None

# Simulate trade signals and send alerts
# We will only send alerts for BUY/SELL signals to avoid spamming
for i, row in df_trades.iterrows():
    signal_type, message = generate_trade_signal(alert_system_state, row['price'])
    df_trades.loc[i, 'signal'] = signal_type

    if signal_type in ['BUY', 'SELL']:
        alert_message = f"Trade Alert for Asset XYZ \nSignal: **{signal_type}**\nPrice: `${row['price']:.2f}`\nTime: {row['timestamp']}"
        df_trades.loc[i, 'alert_message'] = alert_message
        if DISCORD_WEBHOOK_URL != "YOUR_DISCORD_WEBHOOK_URL_HERE":
            send_discord_webhook_message(alert_system_state, DISCORD_WEBHOOK_URL, alert_message)
            # Add a small delay to respect Discord's rate limits, even with backoff
            time.sleep(random.uniform(0.1, 0.5))
        else:
            logger.info(f"Skipping sending alert for {signal_type} (webhook not configured). Message: {alert_message}")
    else:
        logger.debug(f"No alert sent for HOLD signal at price {row['price']:.2f}")

logger.info("Trade signal simulation and alert sending complete.")

# Summarize alert metrics
metrics = summarize_alert_metrics(alert_system_state)
metrics_df = pd.DataFrame([metrics])
display(metrics_df)

# Display a snippet of the trades with signals
print("\nSample of generated trade data with signals:")
display(df_trades[df_trades['signal'] != 'HOLD'].head())

# Plotting the simulated price and trade signals
plt.figure(figsize=(16, 8))
sns.lineplot(x='timestamp', y='price', data=df_trades, label='Asset Price', color='blue')

buy_signals = df_trades[df_trades['signal'] == 'BUY']
sell_signals = df_trades[df_trades['signal'] == 'SELL']

sns.scatterplot(x='timestamp', y='price', data=buy_signals, color='green', marker='^', s=200, label='BUY Signal', zorder=5)
sns.scatterplot(x='timestamp', y='price', data=sell_signals, color='red', marker='v', s=200, label='SELL Signal', zorder=5)

plt.title('Simulated Asset Price with Trade Signals')
plt.xlabel('Timestamp')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()