# Using !pip install to install necessary libraries
!pip install pandas requests matplotlib seaborn arrow
# Optional: install a specific exchange API wrapper if needed (e.g., ccxt)
# !pip install ccxt

# Standard library imports
import logging
import time
import random
from collections import deque
from datetime import datetime, timedelta

# Third-party library imports
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import arrow

# NOTE: Real API fetching removed for notebook demo. Using mock data instead.

def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
    """
    Sets up and configures a logger for consistent output.

    Parameters
    ----------
    name : str
        The name of the logger (e.g., module name).
    level : int, optional
        The logging level (e.g., logging.INFO, logging.DEBUG), defaults to logging.INFO.

    Returns
    -------
    logging.Logger
        The configured logger instance.

    Examples
    --------
    >>> logger = setup_logger(__name__, logging.DEBUG)
    >>> logger.info("Logger configured successfully.")
    """
    logger = logging.getLogger(name)
    logger.setLevel(level)

    # Prevent adding multiple handlers if the logger already has one
    if not logger.handlers:
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        ch = logging.StreamHandler()
        ch.setFormatter(formatter)
        logger.addHandler(ch)

    logger.info(f"Logger '{name}' set up with level {logging.getLevelName(level)}.")
    return logger

# Initialize a global logger for the notebook
logger = setup_logger('funding_rate_monitor')

def create_monitoring_state(
    api_key: str = "",
    api_secret: str = "",
    symbols: list[str] = ['BTCUSDT', 'ETHUSDT'],
    exchange: str = 'binance',
    funding_rate_threshold_percent: float = 0.0005, # e.g., 0.05% funding rate
    lookback_hours: int = 24,
    retry_attempts: int = 5,
    initial_backoff_seconds: float = 1.0,
    alert_cooldown_minutes: int = 30 # Added missing parameter
) -> dict:
    """
    Initializes the state dictionary for the funding rate monitoring system.

    Parameters
    ----------
    api_key : str, optional
        API key for authentication, defaults to "".
    api_secret : str, optional
        API secret for authentication, defaults to "".
    symbols : list[str], optional
        List of cryptocurrency symbols to monitor, defaults to ['BTCUSDT', 'ETHUSDT'].
    exchange : str, optional
        The name of the cryptocurrency exchange, defaults to 'binance'.
    funding_rate_threshold_percent : float, optional
        Funding rate deviation percentage to trigger an alert, defaults to 0.0005.
    lookback_hours : int, optional
        Number of hours of historical data to keep in the deque, defaults to 24.
    retry_attempts : int, optional
        Maximum number of retry attempts for API calls, defaults to 5.
    initial_backoff_seconds : float, optional
        Initial delay for exponential backoff in seconds, defaults to 1.0.
    alert_cooldown_minutes : int, optional
        Cooldown period in minutes before sending another alert for the same symbol, defaults to 30.

    Returns
    -------
    dict
        An initialized state dictionary.

    Examples
    --------
    >>> state = create_monitoring_state(symbols=['XRPUSDT'], funding_rate_threshold_percent=0.001)
    >>> assert 'symbols' in state and 'exchange' in state
    """
    logger.info(f"Initializing monitoring state for exchange: {exchange}")
    state = {
        'api_key': api_key,
        'api_secret': api_secret,
        'symbols': symbols,
        'exchange': exchange,
        'funding_rate_threshold_percent': funding_rate_threshold_percent,
        'lookback_hours': lookback_hours,
        'retry_attempts': retry_attempts,
        'initial_backoff_seconds': initial_backoff_seconds,
        'data': {symbol: deque(maxlen=lookback_hours * 60 // 5) for symbol in symbols}, # Assuming 5-minute data points for `lookback_hours`
        'last_alert_time': {symbol: None for symbol in symbols},
        'alert_cooldown_minutes': alert_cooldown_minutes, # Use the passed parameter
        'processed_messages': deque(maxlen=1000) # To avoid reprocessing duplicate messages/events
    }
    logger.info("Monitoring state initialized successfully.")
    return state

def fetch_data_with_retries(state: dict, url: str, params: dict = None) -> dict | None:
    """
    Disabled in mock mode. This notebook uses generated mock data instead of external APIs.

    Returns
    -------
    None
        Real HTTP fetching is disabled in this demonstration.
    """
    logger.info("fetch_data_with_retries called but API fetching is disabled in mock/demo mode.")
    return None

def fetch_binance_funding_rate(state: dict, symbol: str) -> dict | None:
    """
    Returns deterministic mock funding rate data for the given symbol.

    The mock data generator stores per-symbol counters in `state['mock_counters']` and
    returns repeated sample values (use `state['mock_series']` to override per-symbol).
    """
    # Initialize mock counters and optional series
    state.setdefault('mock_counters', {})
    state.setdefault('mock_series', {})
    counter = state['mock_counters'].get(symbol, 0)

    # Default series: BTCUSDT small positive, ETHUSDT negative
    if symbol in state['mock_series']:
        series = state['mock_series'][symbol]
        value = series[counter % len(series)]
    else:
        if symbol.upper().startswith('BTC'):
            value = 0.000004
        elif symbol.upper().startswith('ETH'):
            value = -0.000041
        else:
            # Generic mock
            value = 0.0

    # Baseline timestamp in ms; increment by 60000ms per sample to spread points
    base_ts = state.get('mock_base_time_ms', 1781049600001)
    ts = int(base_ts + counter * 60000)

    parsed_data = {
        'symbol': symbol,
        'fundingRate': float(value),
        'fundingTime': int(ts),
        'markPrice': float( state.get('mock_markprice', {}).get(symbol, 0.0) )
    }

    # increment counter
    state['mock_counters'][symbol] = counter + 1
    logger.info(f"Generated mock funding rate for {symbol}: {parsed_data}")
    return parsed_data

def add_funding_rate_data(state: dict, new_data: dict) -> dict:
    """
    Adds new funding rate data to the state's historical data deque.

    Parameters
    ----------
    state : dict
        The current state dictionary.
    new_data : dict
        A dictionary containing the latest funding rate data for a symbol.
        Expected keys: 'symbol', 'fundingRate', 'fundingTime', 'markPrice'.

    Returns
    -------
    dict
        The updated state dictionary.

    Examples
    --------
    >>> current_state = create_monitoring_state(symbols=['TESTUSDT'], lookback_hours=1)
    >>> new_fr_data = {'symbol': 'TESTUSDT', 'fundingRate': 0.0001, 'fundingTime': 1678886400000, 'markPrice': 1000.0}
    >>> updated_state = add_funding_rate_data(current_state, new_fr_data)
    >>> assert len(updated_state['data']['TESTUSDT']) == 1
    """
    symbol = new_data['symbol']
    if symbol not in state['data']:
        logger.warning(f"Attempted to add data for unmonitored symbol: {symbol}. Initializing deque.")
        # Initialize deque if symbol somehow wasn't in state['data'] during create_monitoring_state
        state['data'][symbol] = deque(maxlen=state['lookback_hours'] * 60 // 5)

    state['data'][symbol].append(new_data)
    logger.info(f"Added funding rate data for {symbol}. Current data points: {len(state['data'][symbol])}")
    logger.debug(f"Latest data for {symbol}: {new_data}")
    return state

def calculate_funding_rate_stats(state: dict, symbol: str) -> dict | None:
    """
    Calculates statistics for a symbol's historical funding rates and checks for extreme rates.

    Parameters
    ----------
    state : dict
        The current state dictionary.
    symbol : str
        The trading pair symbol.

    Returns
    -------
    dict | None
        A dictionary with statistics (mean_funding_rate, std_funding_rate, is_extreme)
        or None if insufficient data.

    Examples
    --------
    >>> current_state = create_monitoring_state(symbols=['TESTUSDT'])
    >>> # Add some dummy data
    >>> for i in range(10):
    >>>     current_state = add_funding_rate_data(current_state, {'symbol': 'TESTUSDT', 'fundingRate': 0.0001 + i*0.00001, 'fundingTime': 1, 'markPrice': 1})
    >>> stats = calculate_funding_rate_stats(current_state, 'TESTUSDT')
    >>> assert 'mean_funding_rate' in stats if stats else False
    """
    historical_data = list(state['data'][symbol])
    if len(historical_data) < 2: # Need at least 2 data points for std dev
        logger.info(f"Insufficient historical data for {symbol} to calculate stats. Need at least 2, got {len(historical_data)}.")
        return None

    funding_rates = pd.Series([d['fundingRate'] for d in historical_data])
    current_funding_rate = funding_rates.iloc[-1] # Most recent funding rate

    mean_fr = funding_rates.mean()
    std_fr = funding_rates.std()

    is_extreme = False
    # More robust check: flag if deviation from mean exceeds threshold OR absolute funding rate magnitude exceeds threshold
    threshold = state.get('funding_rate_threshold_percent', 0)
    if std_fr > 0:  # Avoid division by zero if all funding rates are the same
        deviation = abs(current_funding_rate - mean_fr)
        if deviation > threshold or abs(current_funding_rate) >= threshold:
            is_extreme = True
            logger.warning(
                f"Extreme funding rate detected for {symbol}: {current_funding_rate:.6f}. "
                f"Mean: {mean_fr:.6f}, Std Dev: {std_fr:.6f}. Threshold: {threshold:.6f}"
            )
        else:
            logger.debug(f"Funding rate for {symbol} is {current_funding_rate:.6f}, not extreme. Mean: {mean_fr:.6f}, Std Dev: {std_fr:.6f}")
    else:
        # If std_fr is 0, all historical rates are identical. Check magnitude against threshold,
        # or any change when threshold is explicitly 0.
        if threshold > 0:
            if abs(current_funding_rate) >= threshold:
                is_extreme = True
                logger.warning(f"Extreme funding rate detected for {symbol}: {current_funding_rate:.6f}. (Zero std dev, magnitude >= threshold {threshold:.6f})")
            else:
                logger.debug(f"Funding rate for {symbol} is {current_funding_rate:.6f}. (Zero std dev, below threshold)")
        else:
            if current_funding_rate != mean_fr:
                is_extreme = True
                logger.warning(f"Extreme funding rate detected for {symbol}: {current_funding_rate:.6f}. (Zero std dev, but changed)")
            else:
                logger.debug(f"Funding rate for {symbol} is {current_funding_rate:.6f}. (Zero std dev)")

    return {
        'symbol': symbol,
        'current_funding_rate': current_funding_rate,
        'mean_funding_rate': mean_fr,
        'std_funding_rate': std_fr,
        'is_extreme': is_extreme
    }

def send_alert(
    state: dict,
    symbol: str,
    current_funding_rate: float,
    mean_funding_rate: float,
    std_funding_rate: float
) -> dict:
    """
    Simulates sending an alert for an extreme funding rate, respecting a cooldown period.

    Parameters
    ----------
    state : dict
        The current state dictionary.
    symbol : str
        The trading pair symbol.
    current_funding_rate : float
        The current funding rate that triggered the alert.
    mean_funding_rate : float
        The historical mean funding rate.
    std_funding_rate : float
        The historical standard deviation of funding rates.

    Returns
    -------
    dict
        The updated state dictionary.

    Examples
    --------
    >>> current_state = create_monitoring_state(symbols=['TESTUSDT'], alert_cooldown_minutes=1)
    >>> updated_state = send_alert(current_state, 'TESTUSDT', 0.0007, 0.0001, 0.00005)
    >>> assert updated_state['last_alert_time']['TESTUSDT'] is not None
    """
    now = datetime.now()
    last_alert = state['last_alert_time'].get(symbol)
    cooldown_minutes = state['alert_cooldown_minutes']

    if last_alert and (now - last_alert).total_seconds() < cooldown_minutes * 60:
        logger.info(f"Alert for {symbol} is in cooldown. Skipping notification.")
        return state

    alert_message = (
        f" EXTREME FUNDING RATE ALERT for {symbol}! \n"
        f"Current Funding Rate: {current_funding_rate:.6f}\n"
        f"Historical Mean: {mean_funding_rate:.6f}\n"
        f"Historical Std Dev: {std_funding_rate:.6f}\n"
        f"Threshold: {state['funding_rate_threshold_percent']:.6f}\n"
        f"Consider reviewing {symbol} on {state['exchange']}."
    )

    logger.critical(alert_message)
    # In a real system, you would integrate with a notification service here.
    # e.g., requests.post('https://api.telegram.org/bot<TOKEN>/sendMessage', data={'chat_id': '<CHAT_ID>', 'text': alert_message})

    state['last_alert_time'][symbol] = now
    logger.info(f"Alert sent for {symbol}. Next alert for this symbol possible after {cooldown_minutes} minutes.")
    return state

def monitor_funding_rates(
    state: dict,
    monitor_interval_seconds: int = 300, # 5 minutes
    duration_minutes: int | None = None,
    max_iterations: int | None = None
) -> dict:
    """
    Orchestrates the continuous monitoring of funding rates, fetching data,
    calculating stats, and sending alerts.

    Parameters
    ----------
    state : dict
        The current state dictionary.
    monitor_interval_seconds : int, optional
        The delay in seconds between each monitoring cycle, defaults to 300 (5 minutes).
    duration_minutes : int | None, optional
        The total duration in minutes to run the monitoring loop. If None,
        it runs indefinitely or until max_iterations is reached, defaults to None.
    max_iterations : int | None, optional
        The maximum number of monitoring cycles to run. If None, it runs
        indefinitely or until duration_minutes is reached, defaults to None.

    Returns
    -------
    dict
        The final state dictionary after the monitoring has completed.

    Examples
    --------
    >>> # Example usage (requires an active state and internet connection for real data)
    >>> # initial_state = create_monitoring_state(symbols=['BTCUSDT'], lookback_hours=1)
    >>> # final_state = monitor_funding_rates(initial_state, duration_minutes=1)
    >>> # assert 'data' in final_state
    """
    logger.info("Starting funding rate monitoring...")
    start_time = datetime.now()
    iteration = 0

    while True:
        iteration += 1
        logger.info(f"Monitoring cycle {iteration} started.")

        for symbol in state['symbols']:
            try:
                # 1. Fetch data
                funding_data = fetch_binance_funding_rate(state, symbol)

                if funding_data:
                    # 2. Add data to state
                    state = add_funding_rate_data(state, funding_data)

                    # 3. Calculate statistics
                    stats = calculate_funding_rate_stats(state, symbol)

                    if stats and stats['is_extreme']:
                        # 4. Send alert if extreme
                        state = send_alert(
                            state,
                            symbol,
                            stats['current_funding_rate'],
                            stats['mean_funding_rate'],
                            stats['std_funding_rate']
                        )
                else:
                    logger.warning(f"Could not fetch funding rate for {symbol}. Skipping stats and alert.")
            except Exception as e:
                logger.error(f"Error during monitoring cycle for {symbol}: {e}")

        # Check termination conditions
        if duration_minutes is not None:
            elapsed_time = (datetime.now() - start_time).total_seconds() / 60
            if elapsed_time >= duration_minutes:
                logger.info(f"Monitoring completed after {duration_minutes} minutes.")
                break

        if max_iterations is not None and iteration >= max_iterations:
            logger.info(f"Monitoring completed after {max_iterations} iterations.")
            break

        logger.info(f"Monitoring cycle {iteration} finished. Sleeping for {monitor_interval_seconds} seconds...")
        time.sleep(monitor_interval_seconds)

    logger.info("Funding rate monitoring stopped.")
    return state

# Initialize the monitoring state
# For a quicker demo, we'll set a small lookback and a higher threshold to potentially see alerts.
initial_state = create_monitoring_state(
    symbols=['BTCUSDT', 'ETHUSDT'],
    lookback_hours=1, # Keep 1 hour of data
    funding_rate_threshold_percent=0.000003, # Lower threshold for demo so alerts trigger (0.0003%)
    alert_cooldown_minutes=1 # Short cooldown for demo
)

logger.info("Initial state created:")
# Note: Avoid printing the full state in production as it might contain sensitive info.
# For demo, we'll print a subset.
print(f"Monitoring Symbols: {initial_state['symbols']}")
print(f"Exchange: {initial_state['exchange']}")
print(f"Funding Rate Threshold: {initial_state['funding_rate_threshold_percent']:.6f}")
print(f"Lookback Hours: {initial_state['lookback_hours']}")

# Run the monitoring loop for a few iterations to collect some data
# Set duration_minutes or max_iterations to a small number for testing.
# Using a very short interval for demonstration, but typically this would be 300 seconds (5 minutes).

# WARNING: Running this might take a few seconds due to time.sleep and API calls.

final_state = monitor_funding_rates(
    initial_state,
    monitor_interval_seconds=10, # Fetch data every 10 seconds for demo
    max_iterations=6 # Run 6 cycles, equivalent to 1 minute of monitoring
)

logger.info("Monitoring run completed. Final state:")
# print(final_state) # This can be large, use with caution.

# Prepare data for visualization
all_fr_data = []
for symbol, data_deque in final_state['data'].items():
    for entry in data_deque:
        # Convert fundingTime (ms) to datetime object
        entry['fundingTime_dt'] = datetime.fromtimestamp(entry['fundingTime'] / 1000)
        all_fr_data.append(entry)

if not all_fr_data:
    logger.warning("No funding rate data collected for visualization.")
else:
    df_fr = pd.DataFrame(all_fr_data)
    df_fr = df_fr.sort_values(by='fundingTime_dt').reset_index(drop=True)

    # Compute per-symbol historical mean and std, and flag alerts
    grouped = df_fr.groupby('symbol')['fundingRate']
    stats = grouped.agg(['mean', 'std']).rename(columns={'mean': 'mean_funding_rate', 'std': 'std_funding_rate'})
    df_fr = df_fr.merge(stats, left_on='symbol', right_index=True)

    threshold_value = final_state.get('funding_rate_threshold_percent', None)

    # Define alert condition: deviation from mean greater than threshold OR absolute funding rate beyond threshold
    if threshold_value is not None:
        df_fr['is_extreme'] = df_fr.apply(lambda r: (abs(r['fundingRate'] - r['mean_funding_rate']) > threshold_value) or (abs(r['fundingRate']) >= threshold_value), axis=1)
    else:
        df_fr['is_extreme'] = False

    # Display the head of the DataFrame and any alerts
    logger.info("Collected Funding Rate Data (first 5 rows):")
    display(df_fr.head())

    alert_rows = df_fr[df_fr['is_extreme']]
    if not alert_rows.empty:
        logger.critical(f'Alerts detected for {list(alert_rows.symbol.unique())}: {len(alert_rows)} point(s)')
        display(alert_rows)
    else:
        logger.info('No alerts detected in collected data.')

    # Plotting: lines for each symbol and highlighted markers for alerts
    plt.figure(figsize=(14, 7))
    sns.lineplot(data=df_fr, x='fundingTime_dt', y='fundingRate', hue='symbol', marker='o')

    # Plot threshold lines if available
    if threshold_value is not None:
        plt.axhline(y=threshold_value, color='r', linestyle='--', label=f'Positive Alert Threshold ({threshold_value:.5f})')
        plt.axhline(y=-threshold_value, color='r', linestyle='--', label=f'Negative Alert Threshold ({-threshold_value:.5f})')

    # Overlay alert points
    if not alert_rows.empty:
        for sym in alert_rows['symbol'].unique():
            subset = alert_rows[alert_rows['symbol'] == sym]
            plt.scatter(subset['fundingTime_dt'], subset['fundingRate'], s=120, facecolors='none', edgecolors='red', linewidths=2, marker='X', label=f'Alert: {sym}')
            # Annotate each alert point with funding rate value
            for _, row in subset.iterrows():
                plt.annotate(f"{row['fundingRate']:.6f}", (row['fundingTime_dt'], row['fundingRate']), textcoords="offset points", xytext=(0,10), ha='center', color='red')

    plt.title('Funding Rates Over Time (with Alert Thresholds)')
    plt.xlabel('Time')
    plt.ylabel('Funding Rate')
    plt.grid(True)
    # Reduce duplicate legend entries
    handles, labels = plt.gca().get_legend_handles_labels()
    by_label = dict(zip(labels, handles))
    plt.legend(by_label.values(), by_label.keys())
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()