# Install necessary libraries
!pip install pandas matplotlib seaborn tqdm

import collections
import datetime
import logging
import math
import random
import time
from typing import Dict, List, Any

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from tqdm.notebook import tqdm

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

def create_alert_system_state(
    asset_name: str,
    initial_price: float,
    volatility: float = 0.01,
    drift: float = 0.0001
) -> Dict[str, Any]:
    """
    Initializes the state dictionary with expanded history capacity.
    """
    logging.info(f"Initializing alert system state for {asset_name}")
    state = {
        'asset_name': asset_name,
        'current_price': initial_price,
        'alerts': {},
        'triggered_alerts_history': collections.deque(maxlen=5000), # Increased capacity
        'simulation_params': {
            'initial_price': initial_price,
            'volatility': volatility,
            'drift': drift,
            'current_time': datetime.datetime.now()
        },
        'price_history': collections.deque(maxlen=5000) # Increased capacity to match simulation cycles
    }
    return state

def add_alert(
    state: Dict[str, Any],
    alert_id: str,
    target_price: float,
    condition: str,
    cooldown_period_seconds: int = 300
) -> Dict[str, Any]:
    """
    Adds a new price alert to the system.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.
    alert_id : str
        A unique identifier for the alert.
    target_price : float
        The price level at which the alert should trigger.
    condition : str
        The trigger condition: 'above' or 'below'.
    cooldown_period_seconds : int, optional
        Minimum time in seconds before the alert can re-trigger, defaults to 300.

    Returns
    -------
    Dict[str, Any]
        The updated state dictionary with the new alert.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> state = add_alert(state, 'test_alert_1', 105.0, 'above')
    >>> assert 'test_alert_1' in state['alerts']
    """
    if condition not in ['above', 'below']:
        logging.error(f"Invalid condition '{condition}' for alert_id '{alert_id}'. Must be 'above' or 'below'.")
        raise ValueError("Condition must be 'above' or 'below'.")

    if alert_id in state['alerts']:
        logging.warning(f"Alert with ID '{alert_id}' already exists. Overwriting.")

    state['alerts'][alert_id] = {
        'target_price': target_price,
        'condition': condition,
        'cooldown_period_seconds': cooldown_period_seconds,
        'last_triggered_time': None
    }
    logging.info(f"Alert '{alert_id}' added: target={target_price}, condition={condition}.")
    return state

def remove_alert(
    state: Dict[str, Any],
    alert_id: str
) -> Dict[str, Any]:
    """
    Removes an existing price alert from the system.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.
    alert_id : str
        The unique identifier of the alert to remove.

    Returns
    -------
    Dict[str, Any]
        The updated state dictionary with the alert removed.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> state = add_alert(state, 'test_alert_1', 105.0, 'above')
    >>> state = remove_alert(state, 'test_alert_1')
    >>> assert 'test_alert_1' not in state['alerts']
    """
    if alert_id in state['alerts']:
        del state['alerts'][alert_id]
        logging.info(f"Alert '{alert_id}' removed successfully.")
    else:
        logging.warning(f"Attempted to remove non-existent alert with ID '{alert_id}'.")
    return state

def simulate_price_data(
    state: Dict[str, Any]
) -> Dict[str, Any]:
    """
    Simulates a new price for the asset based on current parameters.

    Uses a simplified geometric Brownian motion model for price simulation.
    Updates the 'current_price' in the state.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.

    Returns
    -------
    Dict[str, Any]
        The updated state dictionary with the new current_price.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0, volatility=0.01, drift=0.0001)
    >>> original_price = state['current_price']
    >>> state = simulate_price_data(state)
    >>> assert state['current_price'] != original_price
    """
    params = state['simulation_params']
    current_price = state['current_price']

    dt = 1 / 252.0  # Simulate daily steps, scaled for shorter intervals
    price_change = current_price * (params['drift'] * dt + params['volatility'] * math.sqrt(dt) * random.gauss(0, 1))
    new_price = current_price + price_change

    # Ensure price doesn't go negative or too low
    state['current_price'] = max(0.01, new_price)
    state['simulation_params']['current_time'] = datetime.datetime.now()
    state['price_history'].append((state['simulation_params']['current_time'], state['current_price']))
    logging.debug(f"Simulated new price: {state['current_price']:.2f}")
    return state

def check_alerts(
    state: Dict[str, Any]
) -> Dict[str, Any]:
    """
    Checks all active alerts against the current price.

    Triggers alerts if conditions are met and cooldown period has passed.
    Updates the 'last_triggered_time' for triggered alerts.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.

    Returns
    -------
    Dict[str, Any]
        The updated state dictionary.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> state = add_alert(state, 'alert_high', 101.0, 'above')
    >>> state = add_alert(state, 'alert_low', 99.0, 'below')
    >>> state['current_price'] = 101.5 # Should trigger alert_high
    >>> state = check_alerts(state)
    >>> assert len(state['triggered_alerts_history']) == 1
    """
    current_price = state['current_price']
    current_time = state['simulation_params']['current_time']
    triggered_this_cycle = []

    for alert_id, alert_details in state['alerts'].items():
        target_price = alert_details['target_price']
        condition = alert_details['condition']
        last_triggered_time = alert_details['last_triggered_time']
        cooldown_period_seconds = alert_details['cooldown_period_seconds']

        can_trigger = True
        if last_triggered_time:
            time_since_last_trigger = (current_time - last_triggered_time).total_seconds()
            if time_since_last_trigger < cooldown_period_seconds:
                can_trigger = False
                logging.debug(f"Alert '{alert_id}' on cooldown. Remaining: {cooldown_period_seconds - time_since_last_trigger:.0f}s")

        is_triggered = False
        if can_trigger:
            if condition == 'above' and current_price > target_price:
                is_triggered = True
            elif condition == 'below' and current_price < target_price:
                is_triggered = True

        if is_triggered:
            state['alerts'][alert_id]['last_triggered_time'] = current_time
            event = {
                'timestamp': current_time,
                'alert_id': alert_id,
                'condition': condition,
                'target_price': target_price,
                'current_price': current_price,
                'asset': state['asset_name']
            }
            state['triggered_alerts_history'].append(event)
            triggered_this_cycle.append(alert_id)
            logging.info(f"Alert '{alert_id}' triggered! {state['asset_name']} price {current_price:.2f} {condition} {target_price:.2f}")

    return state

def send_notification(
    alert_event: Dict[str, Any]
) -> bool:
    """
    Simulates sending a notification for a triggered alert.

    In a real system, this would integrate with email, SMS, or other notification services.

    Parameters
    ----------
    alert_event : Dict[str, Any]
        A dictionary containing details of the triggered alert event.

    Returns
    -------
    bool
        True if notification was 'sent', False otherwise (simulated).

    Examples
    --------
    >>> event = {
    ...     'timestamp': datetime.datetime.now(),
    ...     'alert_id': 'test_alert_1',
    ...     'condition': 'above',
    ...     'target_price': 105.0,
    ...     'current_price': 105.5,
    ...     'asset': 'TEST'
    ... }
    >>> sent = send_notification(event)
    >>> assert sent is True # Assuming success
    """
    asset = alert_event.get('asset', 'Unknown Asset')
    alert_id = alert_event.get('alert_id', 'Unknown Alert')
    current_price = alert_event.get('current_price', 0.0)
    target_price = alert_event.get('target_price', 0.0)
    condition = alert_event.get('condition', 'N/A')
    timestamp = alert_event.get('timestamp', datetime.datetime.now()).strftime('%Y-%m-%d %H:%M:%S')

    notification_message = (
        f"ALERT! [{timestamp}] {asset} - '{alert_id}' triggered! "
        f"Price {current_price:.2f} is {condition} {target_price:.2f}."
    )
    print(notification_message)
    logging.info(f"Notification simulated for alert '{alert_id}'.")

    # Add random jitter to simulate potential network delays for real notifications
    time.sleep(random.uniform(0.01, 0.1))
    return True

def run_monitoring_cycle(
    state: Dict[str, Any],
    max_retries: int = 3,
    base_delay: float = 0.1
) -> Dict[str, Any]:
    """
    Executes a single price monitoring cycle: fetches price, checks alerts, sends notifications.

    Includes simplified error handling with exponential backoff for price fetching (simulated).

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.
    max_retries : int, optional
        Maximum number of retries for price fetching, defaults to 3.
    base_delay : float, optional
        Base delay in seconds for exponential backoff, defaults to 0.1.

    Returns
    -------
    Dict[str, Any]
        The updated state dictionary after one monitoring cycle.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> state = add_alert(state, 'test_alert', 105.0, 'above')
    >>> # Running a cycle would involve price simulation and alert checks
    >>> state = run_monitoring_cycle(state)
    """
    logging.info("Starting new monitoring cycle...")

    # Simulate price data fetching with retries
    price_fetched = False
    for attempt in range(max_retries):
        try:
            # Removed: if random.random() < 0.05 and attempt == 0:
            # Removed:    raise ConnectionError("Simulated network error during price fetch.")

            state = simulate_price_data(state)
            price_fetched = True
            break
        except ConnectionError as e:
            delay = base_delay * (2 ** attempt) + random.uniform(0, 0.1) # Add jitter
            logging.warning(f"Attempt {attempt + 1}/{max_retries}: Failed to fetch price: {e}. Retrying in {delay:.2f}s...")
            time.sleep(delay)
        except Exception as e:
            logging.error(f"Unexpected error during price simulation: {e}")
            break

    if not price_fetched:
        logging.error("Failed to fetch price data after multiple retries. Skipping alert check for this cycle.")
        return state # Skip alert check if price couldn't be fetched

    # Check alerts
    initial_history_len = len(state['triggered_alerts_history'])
    state = check_alerts(state)
    # Convert deque to list before slicing to get newly triggered events
    newly_triggered_events = list(state['triggered_alerts_history'])[initial_history_len:]

    # Send notifications for newly triggered alerts
    for event in newly_triggered_events:
        send_notification(event)

    logging.info(f"Monitoring cycle completed. Current price: {state['current_price']:.2f}")
    return state

def summarize_alerts(
    state: Dict[str, Any]
) -> pd.DataFrame:
    """
    Provides a summary of all triggered alerts in a pandas DataFrame.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.

    Returns
    -------
    pd.DataFrame
        A DataFrame containing the history of triggered alerts.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> state = add_alert(state, 'test_alert', 100.5, 'above')
    >>> state['current_price'] = 101.0
    >>> state['simulation_params']['current_time'] = datetime.datetime.now()
    >>> state = check_alerts(state)
    >>> df_summary = summarize_alerts(state)
    >>> assert not df_summary.empty
    """
    if not state['triggered_alerts_history']:
        logging.info("No alerts have been triggered yet.")
        return pd.DataFrame(
            columns=['timestamp', 'alert_id', 'condition', 'target_price', 'current_price', 'asset']
        ).set_index('timestamp')

    df = pd.DataFrame(list(state['triggered_alerts_history']))
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df = df.set_index('timestamp').sort_index()
    logging.info("Generated triggered alerts summary DataFrame.")
    return df

def get_price_history_df(
    state: Dict[str, Any]
) -> pd.DataFrame:
    """
    Retrieves the recorded price history as a pandas DataFrame.

    Parameters
    ----------
    state : Dict[str, Any]
        The current alert system state.

    Returns
    -------
    pd.DataFrame
        A DataFrame with 'timestamp' and 'price' columns.

    Examples
    --------
    >>> state = create_alert_system_state('TEST', 100.0)
    >>> for _ in range(5): state = simulate_price_data(state)
    >>> df_history = get_price_history_df(state)
    >>> assert not df_history.empty
    """
    if not state['price_history']:
        logging.info("No price history recorded yet.")
        return pd.DataFrame(columns=['timestamp', 'price']).set_index('timestamp')

    df = pd.DataFrame(list(state['price_history']), columns=['timestamp', 'price'])
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df = df.set_index('timestamp').sort_index()
    logging.info("Generated price history DataFrame.")
    return df

initial_asset_price = 96000.0
# Reset state for BTC/USDT with adjusted BTC price levels
alert_system_state = create_alert_system_state(
    asset_name='BTC/USDT',
    initial_price=initial_asset_price,
    volatility=0.005,
    drift=0.0
)

print(f"Initial state created for {alert_system_state['asset_name']} at ${alert_system_state['current_price']:,.2f}")

# Remove obsolete alerts from the previous low-price simulation
old_alerts = ['Strong_Resistance', 'Major_Support', 'Minor_Sell', 'Minor_Buy', 'Test_Cooldown']
for alert_id in old_alerts:
    if alert_id in alert_system_state['alerts']:
        alert_system_state = remove_alert(alert_system_state, alert_id)

print(f"Cleaned up state. Current active alerts: {list(alert_system_state['alerts'].keys())}")

# Add a comprehensive set of BTC-specific alerts
alert_system_state = add_alert(alert_system_state, 'Strong_Resistance', 96500.0, 'above', cooldown_period_seconds=10)
alert_system_state = add_alert(alert_system_state, 'Minor_Sell', 96300.0, 'above', cooldown_period_seconds=10)
alert_system_state = add_alert(alert_system_state, 'Minor_Buy', 95700.0, 'below', cooldown_period_seconds=10)
alert_system_state = add_alert(alert_system_state, 'Major_Support', 95500.0, 'below', cooldown_period_seconds=10)
alert_system_state = add_alert(alert_system_state, 'BTC_Target', 96000.0, 'above', cooldown_period_seconds=30)

num_cycles = 300
print(f"Simulating {num_cycles} monitoring cycles for BTC/USDT with full alert set...")

for i in range(num_cycles):
    alert_system_state = run_monitoring_cycle(alert_system_state)

print("Simulation complete.")

# Get summary of triggered alerts from the full 5000-cycle run
alert_summary_df = summarize_alerts(alert_system_state)

if not alert_summary_df.empty:
    print("\n--- Triggered Alerts Summary ---")
    display(alert_summary_df.head())
    print(f"Total unique alerts triggered: {len(alert_summary_df['alert_id'].unique())}")
    print(f"Total alert triggers: {len(alert_summary_df)}")
else:
    print("\nNo alerts were triggered during this full simulation.")

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

# Prepare BTC Data
price_df = get_price_history_df(alert_system_state).reset_index()
price_df['cycle'] = price_df.index
alert_summary = summarize_alerts(alert_system_state)

plt.figure(figsize=(14, 8))

# Plot Price
sns.lineplot(x='cycle', y='price', data=price_df, label='BTC Price', color='orange', linewidth=2)

# Plot all active alert levels dynamically
colors = {'Strong_Resistance': 'red', 'Minor_Sell': 'salmon', 'Minor_Buy': 'lightgreen', 'Major_Support': 'darkgreen', 'BTC_Target': 'blue'}

for alert_id, details in alert_system_state['alerts'].items():
    plt.axhline(y=details['target_price'],
                color=colors.get(alert_id, 'gray'),
                linestyle='--', alpha=0.6,
                label=f"{alert_id} (${details['target_price']:,.0f})")

# Overlay Triggers
if not alert_summary.empty:
    # Filter to only show triggers belonging to the current BTC simulation (high price range)
    btc_triggers = alert_summary[alert_summary['current_price'] > 1000].reset_index()

    triggers_with_cycle = pd.merge_asof(
        btc_triggers.sort_values('timestamp'),
        price_df[['timestamp', 'cycle']].sort_values('timestamp'),
        on='timestamp'
    )

    sns.scatterplot(x='cycle', y='current_price', hue='alert_id', data=triggers_with_cycle,
                    s=150, marker='X', zorder=5, palette='bright')

plt.title('BTC/USDT Multi-Level Alert Simulation')
plt.xlabel('Cycle Index')
plt.ylabel('Price (USDT)')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()