import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Set random seed for reproducibility
np.random.seed(42)

# Generate mock time-series data
dates = pd.date_range(start='2023-01-01', periods=200, freq='H')

# Simulate price data with some trend and noise
price = 100 + np.cumsum(np.random.randn(len(dates)) * 0.1) + np.sin(np.arange(len(dates)) * 0.05) * 5

# Simulate volume data with periods of high and low liquidity
# Create periods of low volume (illiquidity)
volume = np.random.randint(500, 5000, len(dates)).astype(float)
volume[50:70] = np.random.randint(50, 200, 20) # Low liquidity period 1
volume[120:140] = np.random.randint(50, 250, 20) # Low liquidity period 2

# Create a DataFrame
df = pd.DataFrame({'date': dates, 'price': price, 'volume': volume})
df = df.set_index('date')

print("Generated mock financial data:")
display(df.head())
print(f"\nTotal data points: {len(df)}")

def apply_static_volume_liquidity_filter(df: pd.DataFrame, volume_column: str, threshold: float) -> pd.DataFrame:
    """
    Applies a static volume-based liquidity filter to a DataFrame.

    Args:
        df (pd.DataFrame): The input DataFrame containing financial data.
        volume_column (str): The name of the column representing trading volume.
        threshold (float): The minimum volume required for a data point to be considered liquid.

    Returns:
        pd.DataFrame: A new DataFrame containing only the liquid data points.
    """
    if volume_column not in df.columns:
        raise ValueError(f"Volume column '{volume_column}' not found in DataFrame.")

    # Filter the DataFrame based on the volume threshold
    filtered_df = df[df[volume_column] >= threshold].copy()

    return filtered_df

# Example Usage:
static_volume_threshold = 1000 # Example threshold
filtered_df_static = apply_static_volume_liquidity_filter(df, 'volume', static_volume_threshold)

print(f"Original data points: {len(df)}")
print(f"Data points after static filter (volume >= {static_volume_threshold}): {len(filtered_df_static)}")
display(filtered_df_static.head())

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(14, 10), sharex=True)

# Plot original price data
ax1.plot(df.index, df['price'], label='Original Price', color='skyblue', alpha=0.7)
ax1.scatter(filtered_df_static.index, filtered_df_static['price'],
            color='red', marker='o', s=10, label=f'Filtered Price (Volume >= {static_volume_threshold})')
ax1.set_title('Price Data: Original vs. Statically Filtered')
ax1.set_ylabel('Price')
ax1.legend()
ax1.grid(True, linestyle='--', alpha=0.6)

# Plot original volume and the threshold
ax2.plot(df.index, df['volume'], label='Original Volume', color='lightgray', alpha=0.8)
ax2.axhline(y=static_volume_threshold, color='green', linestyle='--', label='Static Volume Threshold')
ax2.fill_between(df.index, 0, df['volume'], where=df['volume'] < static_volume_threshold,
                 color='orange', alpha=0.3, label='Illiquid Periods')
ax2.set_title('Volume Data with Static Liquidity Threshold')
ax2.set_xlabel('Date')
ax2.set_ylabel('Volume')
ax2.legend()
ax2.grid(True, linestyle='--', alpha=0.6)

plt.tight_layout()
plt.show()

print("\nInterpretation:")
print("The top plot shows that the red circles (filtered price points) are only present when the volume is above the static threshold. The bottom plot clearly indicates the illiquid periods (shaded orange) where the volume falls below the green dashed line threshold. This filter effectively removes data from these less active periods, ensuring that subsequent analysis focuses solely on sufficiently liquid market conditions.")

def apply_rolling_volume_liquidity_filter(df: pd.DataFrame, volume_column: str, window: int, threshold_multiplier: float) -> pd.DataFrame:
    """
    Applies a rolling average volume-based liquidity filter to a DataFrame.

    Args:
        df (pd.DataFrame): The input DataFrame containing financial data.
        volume_column (str): The name of the column representing trading volume.
        window (int): The number of periods for the rolling average calculation.
        threshold_multiplier (float): A multiplier applied to the rolling average volume
                                      to determine the adaptive threshold.

    Returns:
        pd.DataFrame: A new DataFrame containing only the liquid data points.
    """
    if volume_column not in df.columns:
        raise ValueError(f"Volume column '{volume_column}' not found in DataFrame.")

    # Calculate the rolling average volume
    df['rolling_avg_volume'] = df[volume_column].rolling(window=window, min_periods=1).mean()

    # Calculate the adaptive threshold
    df['adaptive_threshold'] = df['rolling_avg_volume'] * threshold_multiplier

    # Apply the filter: current volume must be greater than or equal to the adaptive threshold
    filtered_df = df[df[volume_column] >= df['adaptive_threshold']].copy()

    # Drop auxiliary columns before returning
    filtered_df = filtered_df.drop(columns=['rolling_avg_volume', 'adaptive_threshold'])

    return filtered_df

# Example Usage:
rolling_window = 20  # 20-period rolling average
rolling_threshold_multiplier = 0.8 # Current volume must be at least 80% of the 20-period rolling average

filtered_df_rolling = apply_rolling_volume_liquidity_filter(
    df.copy(), 'volume', rolling_window, rolling_threshold_multiplier
)

print(f"Original data points: {len(df)}")
print(f"Data points after rolling filter (volume >= {rolling_threshold_multiplier} * {rolling_window}-period rolling avg): {len(filtered_df_rolling)}")
display(filtered_df_rolling.head())

# Recalculate rolling average and adaptive threshold for plotting
df_plot = df.copy()
df_plot['rolling_avg_volume'] = df_plot['volume'].rolling(window=rolling_window, min_periods=1).mean()
df_plot['adaptive_threshold'] = df_plot['rolling_avg_volume'] * rolling_threshold_multiplier

fig, ax = plt.subplots(figsize=(14, 7))

# Plot original volume
ax.plot(df_plot.index, df_plot['volume'], label='Original Volume', color='lightgray', alpha=0.8)

# Plot static threshold
ax.axhline(y=static_volume_threshold, color='green', linestyle='--', label=f'Static Threshold ({static_volume_threshold})')

# Plot rolling adaptive threshold
ax.plot(df_plot.index, df_plot['adaptive_threshold'], color='purple', linestyle=':',
        label=f'Rolling Adaptive Threshold ({rolling_threshold_multiplier} * {rolling_window}-period avg)')

# Indicate periods filtered by static
ax.fill_between(df_plot.index, 0, df_plot['volume'], where=df_plot['volume'] < static_volume_threshold,
                 color='red', alpha=0.1, label='Filtered by Static Threshold')

# Indicate periods filtered by rolling (only where static wouldn't catch it, for clarity)
ax.fill_between(df_plot.index, 0, df_plot['volume'],
                 where=(df_plot['volume'] < df_plot['adaptive_threshold']) & (df_plot['volume'] >= static_volume_threshold),
                 color='blue', alpha=0.1, label='Filtered by Rolling Only')

ax.set_title('Comparison of Static vs. Rolling Liquidity Filters')
ax.set_xlabel('Date')
ax.set_ylabel('Volume')
ax.legend()
ax.grid(True, linestyle='--', alpha=0.6)
plt.tight_layout()
plt.show()

print("\nInterpretation:")
print("This plot demonstrates how the rolling adaptive threshold (purple dotted line) dynamically changes based on the recent average volume, unlike the fixed static threshold (green dashed line). You can observe periods where the rolling filter might be more or less permissive than the static one, depending on the current market's historical liquidity levels. The shaded areas highlight where each filter would discard data, showcasing their distinct filtering characteristics. The rolling filter adapts to recent market conditions, which can be advantageous in volatile or trending volume environments.")