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

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

# Generate mock trade data
start_time = pd.Timestamp('2023-01-01 09:00:00')
trade_data = []
current_price = 100.0

for i in range(100):
    timestamp = start_time + pd.Timedelta(minutes=i)
    # Simulate price movement
    price_change = np.random.normal(0, 0.5) # Small random walk
    current_price += price_change
    current_price = max(90.0, min(110.0, current_price)) # Keep price within bounds
    volume = np.random.randint(100, 1000) # Random volume between 100 and 1000
    trade_data.append({'timestamp': timestamp, 'price': current_price, 'volume': volume})

df = pd.DataFrame(trade_data)

print("Mock Trade Data Head:")
display(df.head())
print("\nMock Trade Data Info:")
df.info()

def calculate_vwap_single_period(df: pd.DataFrame) -> float:
    """
    Calculates the Volume Weighted Average Price (VWAP) for a given period.

    Formula: Sum(Price * Volume) / Sum(Volume)

    Args:
        df (pd.DataFrame): DataFrame containing 'price' and 'volume' columns.

    Returns:
        float: The calculated VWAP for the entire period.
    """
    # Ensure price and volume are numeric
    df['price'] = pd.to_numeric(df['price'])
    df['volume'] = pd.to_numeric(df['volume'])

    total_value = (df['price'] * df['volume']).sum()
    total_volume = df['volume'].sum()

    if total_volume == 0:
        return 0.0 # Avoid division by zero
    return total_value / total_volume


# Calculate VWAP for the entire mock dataset
period_vwap = calculate_vwap_single_period(df)
print(f"The VWAP for the entire trading period is: {period_vwap:.2f}")
# Interpretation: This is the average price at which the asset traded, weighted by volume, for the whole period.

def calculate_cumulative_vwap(df: pd.DataFrame) -> pd.Series:
    """
    Calculates the cumulative Volume Weighted Average Price (VWAP) over time.

    Formula: Cumulative Sum(Price * Volume) / Cumulative Sum(Volume)

    Args:
        df (pd.DataFrame): DataFrame containing 'price' and 'volume' columns,
                            sorted by time.

    Returns:
        pd.Series: A Series containing the cumulative VWAP at each point in time.
    """
    # Ensure price and volume are numeric
    df['price'] = pd.to_numeric(df['price'])
    df['volume'] = pd.to_numeric(df['volume'])

    cumulative_value = (df['price'] * df['volume']).cumsum()
    cumulative_volume = df['volume'].cumsum()

    # Handle cases where cumulative_volume might be zero at the start
    cumulative_vwap = cumulative_value / cumulative_volume.replace(0, np.nan)
    return cumulative_vwap


# Calculate cumulative VWAP and add it to the DataFrame
df['cumulative_vwap'] = calculate_cumulative_vwap(df)
print("Mock Data with Cumulative VWAP Head:")
display(df[['timestamp', 'price', 'volume', 'cumulative_vwap']].head())
print("\nMock Data with Cumulative VWAP Tail:")
display(df[['timestamp', 'price', 'volume', 'cumulative_vwap']].tail())

def calculate_twap_single_period(df: pd.DataFrame) -> float:
    """
    Calculates the Time Weighted Average Price (TWAP) for a given period.

    Formula: Sum(Price) / Count(Price)

    Args:
        df (pd.DataFrame): DataFrame containing a 'price' column.

    Returns:
        float: The calculated TWAP for the entire period.
    """
    # Ensure price is numeric
    df['price'] = pd.to_numeric(df['price'])

    if df['price'].empty:
        return 0.0
    return df['price'].mean()


# Calculate TWAP for the entire mock dataset
period_twap = calculate_twap_single_period(df)
print(f"The TWAP for the entire trading period is: {period_twap:.2f}")
# Interpretation: This is the simple average price of the asset over the entire period, without considering trade volume.

def calculate_cumulative_twap(df: pd.DataFrame) -> pd.Series:
    """
    Calculates the cumulative Time Weighted Average Price (TWAP) over time.

    Formula: Cumulative Sum(Price) / Cumulative Count(Price)

    Args:
        df (pd.DataFrame): DataFrame containing a 'price' column, sorted by time.

    Returns:
        pd.Series: A Series containing the cumulative TWAP at each point in time.
    """
    # Ensure price is numeric
    df['price'] = pd.to_numeric(df['price'])

    cumulative_sum_price = df['price'].cumsum()
    cumulative_count_price = pd.Series(np.arange(1, len(df) + 1), index=df.index)

    # Handle cases where cumulative_count_price might be zero (though unlikely with arange)
    cumulative_twap = cumulative_sum_price / cumulative_count_price.replace(0, np.nan)
    return cumulative_twap


# Calculate cumulative TWAP and add it to the DataFrame
df['cumulative_twap'] = calculate_cumulative_twap(df)
print("Mock Data with Cumulative TWAP Head:")
display(df[['timestamp', 'price', 'volume', 'cumulative_twap']].head())
print("\nMock Data with Cumulative TWAP Tail:")
display(df[['timestamp', 'price', 'volume', 'cumulative_twap']].tail())

fig, axes = plt.subplots(3, 1, figsize=(15, 18), sharex=True)

# Plot 1: Price over Time
axes[0].plot(df['timestamp'], df['price'], label='Trade Price', color='blue', alpha=0.7)
axes[0].set_title('Trade Price Over Time')
axes[0].set_ylabel('Price')
axes[0].legend()
axes[0].grid(True, linestyle='--', alpha=0.6)

# Plot 2: Volume over Time
axes[1].bar(df['timestamp'], df['volume'], label='Trade Volume', color='green', alpha=0.7, width=pd.Timedelta(minutes=0.5))
axes[1].set_title('Trade Volume Over Time')
axes[1].set_ylabel('Volume')
axes[1].legend()
axes[1].grid(True, linestyle='--', alpha=0.6)

# Plot 3: Price with Cumulative VWAP and TWAP
axes[2].plot(df['timestamp'], df['price'], label='Trade Price', color='blue', alpha=0.7)
axes[2].plot(df['timestamp'], df['cumulative_vwap'], label='Cumulative VWAP', color='red', linestyle='--')
axes[2].plot(df['timestamp'], df['cumulative_twap'], label='Cumulative TWAP', color='purple', linestyle=':')
axes[2].set_title('Price, Cumulative VWAP, and Cumulative TWAP Over Time')
axes[2].set_xlabel('Timestamp')
axes[2].set_ylabel('Price / Weighted Average')
axes[2].legend()
axes[2].grid(True, linestyle='--', alpha=0.6)

plt.tight_layout()
plt.show()

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

plt.plot(df['timestamp'], df['cumulative_vwap'], label='Cumulative VWAP', color='red', linestyle='-', linewidth=2)
plt.plot(df['timestamp'], df['cumulative_twap'], label='Cumulative TWAP', color='purple', linestyle='--', linewidth=2)

# Add a benchmark: simple average price for the whole period
simple_average_price = df['price'].mean()
plt.axhline(y=simple_average_price, color='gray', linestyle=':', label=f'Simple Average Price ({simple_average_price:.2f})')

# Optional: Add starting price as another benchmark
starting_price = df['price'].iloc[0]
plt.axhline(y=starting_price, color='orange', linestyle='-.', label=f'Starting Price ({starting_price:.2f})')

plt.title('Cumulative VWAP and TWAP with Benchmarks Over Time')
plt.xlabel('Timestamp')
plt.ylabel('Weighted Average Price')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.tight_layout()
plt.show()