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

# Creating data with variance in both price and spread
np.random.seed(42)
num_data_points = 50
timestamp = pd.to_datetime(pd.date_range(start='2023-01-01', periods=num_data_points, freq='1min'))

# Base linear trend plus random noise for variance
noise = np.random.normal(0, 0.2, num_data_points)
base_trend = np.linspace(100.00, 105.00, num_data_points) + noise

bid_prices = np.round(base_trend, 2)

# Introduce variance into the spread itself (centered around 0.9)
spread_variance = np.random.normal(0.9, 0.05, num_data_points)
ask_prices = np.round(bid_prices + spread_variance, 2)

data = pd.DataFrame({
    'timestamp': timestamp,
    'bid': bid_prices,
    'ask': ask_prices
})

def calculate_nominal_spread(bid_price: float, ask_price: float) -> float:
    return ask_price - bid_price

# Apply calculations
data['nominal_spread'] = data.apply(lambda row: calculate_nominal_spread(row['bid'], row['ask']), axis=1)

print("--- Data Generated with Price & Spread Variance ---")
display(data.head())

def calculate_percentage_spread(bid_price: float, ask_price: float) -> float:
    midpoint_price = (bid_price + ask_price) / 2
    nominal_spread = ask_price - bid_price
    if midpoint_price == 0:
        return 0.0
    return (nominal_spread / midpoint_price) * 100

data['percentage_spread'] = data.apply(lambda row: calculate_percentage_spread(row['bid'], row['ask']), axis=1)
display(data.head())

np.random.seed(43)
trade_prices = []
trade_types = []

for i in range(len(data)):
    mid_price = (data.loc[i, 'bid'] + data.loc[i, 'ask']) / 2
    if np.random.rand() > 0.5:
        trade_type = 'buy'
        trade_price = np.round(np.random.uniform(mid_price, data.loc[i, 'ask']), 2)
    else:
        trade_type = 'sell'
        trade_price = np.round(np.random.uniform(data.loc[i, 'bid'], mid_price), 2)
    trade_prices.append(trade_price)
    trade_types.append(trade_type)

data['trade_price'] = trade_prices
data['trade_type'] = trade_types

def calculate_effective_spread(bid_price_at_order: float, ask_price_at_order: float, trade_price: float, trade_type: str) -> float:
    midpoint_at_order = (bid_price_at_order + ask_price_at_order) / 2
    if trade_type == 'buy':
        return 2 * (trade_price - midpoint_at_order)
    elif trade_type == 'sell':
        return 2 * (midpoint_at_order - trade_price)
    return 0.0

data['effective_spread'] = data.apply(lambda row: calculate_effective_spread(row['bid'], row['ask'], row['trade_price'], row['trade_type']), axis=1)
display(data.head())

np.random.seed(43)

# Mock trade data, assuming some price improvement or slippage
trade_prices = []
trade_types = []

for i in range(num_data_points):
    mid_price = (data.loc[i, 'bid'] + data.loc[i, 'ask']) / 2
    if np.random.rand() > 0.5: # Simulate a buy order
        trade_type = 'buy'
        # Trade price slightly above mid, sometimes slightly below ask
        trade_price = np.round(np.random.uniform(mid_price, data.loc[i, 'ask']), 2)
    else: # Simulate a sell order
        trade_type = 'sell'
        # Trade price slightly below mid, sometimes slightly above bid
        trade_price = np.round(np.random.uniform(data.loc[i, 'bid'], mid_price), 2)
    trade_prices.append(trade_price)
    trade_types.append(trade_type)

data['trade_price'] = trade_prices
data['trade_type'] = trade_types

def calculate_effective_spread(bid_price_at_order: float, ask_price_at_order: float, trade_price: float, trade_type: str) -> float:
    """
    Calculates the effective bid-ask spread.

    Args:
        bid_price_at_order (float): Bid price at the time the order was placed.
        ask_price_at_order (float): Ask price at the time the order was placed.
        trade_price (float): The actual execution price of the trade.
        trade_type (str): Type of the trade, either 'buy' or 'sell'.

    Returns:
        float: The effective bid-ask spread.
    """
    midpoint_at_order = (bid_price_at_order + ask_price_at_order) / 2
    if trade_type == 'buy':
        return 2 * (trade_price - midpoint_at_order)
    elif trade_type == 'sell':
        return 2 * (midpoint_at_order - trade_price)
    else:
        raise ValueError("Trade type must be 'buy' or 'sell'.")

# Apply the function to mock data
data['effective_spread'] = data.apply(lambda row:
    calculate_effective_spread(row['bid'], row['ask'], row['trade_price'], row['trade_type']),
    axis=1
)

print("--- Effective Spread Calculation ---")
display(data.head())
print("\nInterpretation: The effective spread provides a more accurate picture of transaction costs by comparing the actual trade price to the mid-price at the time of the order. A negative effective spread for a buy order would indicate a highly favorable execution (bought below mid-price).")

np.random.seed(44)

# Simulate post-trade midpoint price (e.g., 5 minutes after the trade)
# For simplicity, we'll shift the mid_price or add some noise
post_trade_mid_prices = []
for i in range(num_data_points):
    current_mid = (data.loc[i, 'bid'] + data.loc[i, 'ask']) / 2
    # Simulate a slight random walk for post-trade mid price
    post_trade_mid = current_mid + np.random.uniform(-0.02, 0.02)
    post_trade_mid_prices.append(np.round(post_trade_mid, 2))

data['post_trade_mid_price'] = post_trade_mid_prices

def calculate_realized_spread(trade_price: float, post_trade_mid_price: float, trade_type: str) -> float:
    """
    Calculates the realized spread from the perspective of the trade initiator.

    Args:
        trade_price (float): The actual execution price of the trade.
        post_trade_mid_price (float): The midpoint price a short period after the trade (e.g., T+5).
        trade_type (str): Type of the trade, either 'buy' or 'sell'.

    Returns:
        float: The realized spread (from trader's perspective).
    """
    if trade_type == 'buy':
        return trade_price - post_trade_mid_price
    elif trade_type == 'sell':
        return post_trade_mid_price - trade_price
    else:
        raise ValueError("Trade type must be 'buy' or 'sell'.")

# Apply the function to mock data
data['realized_spread'] = data.apply(lambda row:
    calculate_realized_spread(row['trade_price'], row['post_trade_mid_price'], row['trade_type']),
    axis=1
)

print("--- Realized Spread Calculation ---")
display(data.head())
print("\nInterpretation: The realized spread quantifies the adverse selection component. A negative realized spread for a buy order indicates that the mid-price rose after your purchase, meaning you paid less relative to the future market price. A positive value means you paid more relative to the future market price.")

fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Plot 1: Distribution of Effective Spread
sns.histplot(data['effective_spread'], kde=True, ax=axes[0], color='blue', label='Effective Spread')
axes[0].axvline(data['effective_spread'].mean(), color='red', linestyle='--', label=f'Mean: {data["effective_spread"].mean():.4f}')
axes[0].set_title('Distribution of Effective Spread')
axes[0].set_xlabel('Effective Spread Value')
axes[0].set_ylabel('Frequency / Density')
axes[0].legend()
axes[0].grid(True, linestyle='--', alpha=0.7);

# Plot 2: Distribution of Realized Spread
sns.histplot(data['realized_spread'], kde=True, ax=axes[1], color='green', label='Realized Spread')
axes[1].axvline(data['realized_spread'].mean(), color='purple', linestyle='--', label=f'Mean: {data["realized_spread"].mean():.4f}')
axes[1].set_title('Distribution of Realized Spread')
axes[1].set_xlabel('Realized Spread Value')
axes[1].set_ylabel('Frequency / Density')
axes[1].legend()
axes[1].grid(True, linestyle='--', alpha=0.7);

plt.tight_layout()
plt.show()

print("Interpretation:")
print("The first histogram shows the distribution of the effective spread. A distribution centered near zero or slightly positive suggests efficient execution costs. A longer tail on the positive side indicates trades that incurred higher-than-expected costs relative to the mid-price at order entry. The mean effective spread helps quantify the average transaction cost incurred by traders.")
print("\nThe second histogram displays the distribution of the realized spread. This distribution's mean and shape reveal how often trades were subject to adverse selection (market moving against the trader post-trade) or benefited from favorable price movements. A mean near zero suggests market makers are generally able to capture the spread without significant losses to adverse selection, or that traders' profits/losses from post-trade price movements balance out. Negative values for a buyer's realized spread (meaning the post-trade mid-price was higher than their trade price) indicate a 'good' trade from the perspective of beating future market movement.")

np.random.seed(44)
post_trade_mid_prices = []
for i in range(len(data)):
    current_mid = (data.loc[i, 'bid'] + data.loc[i, 'ask']) / 2
    post_trade_mid = current_mid + np.random.uniform(-0.1, 0.1)
    post_trade_mid_prices.append(np.round(post_trade_mid, 2))

data['post_trade_mid_price'] = post_trade_mid_prices

def calculate_realized_spread(trade_price: float, post_trade_mid_price: float, trade_type: str) -> float:
    if trade_type == 'buy':
        return trade_price - post_trade_mid_price
    elif trade_type == 'sell':
        return post_trade_mid_price - trade_price
    return 0.0

data['realized_spread'] = data.apply(lambda row: calculate_realized_spread(row['trade_price'], row['post_trade_mid_price'], row['trade_type']), axis=1)
display(data.head())

data['mid_price'] = (data['bid'] + data['ask']) / 2
fig, axes = plt.subplots(3, 1, figsize=(15, 14), sharex=True)

# Panel 1
axes[0].plot(data['timestamp'], data['bid'], label='Bid Price', color='red', linewidth=1, marker='o', markersize=2)
axes[0].plot(data['timestamp'], data['ask'], label='Ask Price', color='green', linewidth=1, marker='x', markersize=2)
axes[0].plot(data['timestamp'], data['mid_price'], label='Mid Price', color='blue', linestyle='--')
axes[0].fill_between(data['timestamp'], data['bid'], data['ask'], color='yellow', alpha=0.2)
axes[0].set_title('Bid, Ask, and Mid Prices (Non-linear with variable spread)')
axes[0].set_ylabel('Price')
axes[0].legend(loc='upper left')
axes[0].grid(True, linestyle='--', alpha=0.5)

# Panel 2: Nominal Spread with Variance
axes[1].plot(data['timestamp'], data['nominal_spread'], label='Nominal Spread', color='purple', linewidth=1.5, marker='s', markersize=3)
axes[1].set_ylim(0.5, 1.3)
axes[1].set_title('Nominal Bid-Ask Spread (Variable around 0.9)')
axes[1].set_ylabel('Spread Value')
axes[1].legend()
axes[1].grid(True, linestyle='--', alpha=0.7)

# Panel 3
axes[2].plot(data['timestamp'], data['percentage_spread'], label='Percentage Spread (%)', color='brown')
axes[2].set_title('Percentage Bid-Ask Spread')
axes[2].set_xlabel('Time')
axes[2].set_ylabel('Spread (%)')
axes[2].legend()
axes[2].grid(True, linestyle='--', alpha=0.7)

plt.tight_layout()
plt.show()

fig, axes = plt.subplots(1, 2, figsize=(16, 6))

# Plot 1: Distribution of Effective Spread
sns.histplot(data['effective_spread'], kde=True, ax=axes[0], color='blue', label='Effective Spread')
axes[0].axvline(data['effective_spread'].mean(), color='red', linestyle='--', label=f'Mean: {data["effective_spread"].mean():.4f}')
axes[0].set_title('Distribution of Effective Spread')
axes[0].set_xlabel('Effective Spread Value')
axes[0].set_ylabel('Frequency / Density')
axes[0].legend()
axes[0].grid(True, linestyle='--', alpha=0.7);

# Plot 2: Distribution of Realized Spread
sns.histplot(data['realized_spread'], kde=True, ax=axes[1], color='green', label='Realized Spread')
axes[1].axvline(data['realized_spread'].mean(), color='purple', linestyle='--', label=f'Mean: {data["realized_spread"].mean():.4f}')
axes[1].set_title('Distribution of Realized Spread')
axes[1].set_xlabel('Realized Spread Value')
axes[1].set_ylabel('Frequency / Density')
axes[1].legend()
axes[1].grid(True, linestyle='--', alpha=0.7);

plt.tight_layout()
plt.show()

print("Interpretation:")
print("The first histogram shows the distribution of the effective spread. A distribution centered near zero or slightly positive suggests efficient execution costs. A longer tail on the positive side indicates trades that incurred higher-than-expected costs relative to the mid-price at order entry. The mean effective spread helps quantify the average transaction cost incurred by traders.")
print("\nThe second histogram displays the distribution of the realized spread. This distribution's mean and shape reveal how often trades were subject to adverse selection (market moving against the trader post-trade) or benefited from favorable price movements. A mean near zero suggests market makers are generally able to capture the spread without significant losses to adverse selection, or that traders' profits/losses from post-trade price movements balance out. Negative values for a buyer's realized spread (meaning the post-trade mid-price was higher than their trade price) indicate a 'good' trade from the perspective of beating future market movement.")