# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def calculate_historical_volatility(prices, lookback_period=20, annualize=True, annualization_factor=252):
    r"""
    Calculates the historical volatility of an asset.

    Inputs:
    - prices (pd.Series or np.array): A series or array of asset closing prices.
    - lookback_period (int): The number of periods to consider for volatility calculation.
    - annualize (bool): Whether to annualize the volatility.
    - annualization_factor (int): The factor to use for annualization (e.g., 252 for trading days).

    Outputs:
    - float: The calculated historical volatility.

    Formulas:
    1. Logarithmic returns: $R_t = \ln(P_t / P_{t-1})$
    2. Standard deviation of returns over the lookback period.
    3. Annualized volatility = Daily Volatility * $\sqrt{\text{annualization_factor}}$
    """
    if len(prices) < lookback_period:
        return np.nan

    # Calculate logarithmic returns
    returns = np.log(prices / prices.shift(1)).dropna()

    if len(returns) < lookback_period:
        return np.nan

    # Calculate standard deviation of returns over the lookback period
    daily_volatility = returns.rolling(window=lookback_period).std().iloc[-1]

    if annualize:
        return daily_volatility * np.sqrt(annualization_factor)
    else:
        return daily_volatility

# --- Example Demonstration of Volatility Calculation ---
print("\n--- Demonstrating Volatility Calculation ---")
# Generate mock price data
np.random.seed(42)
mock_prices = pd.Series(100 + np.cumsum(np.random.normal(0, 1, 100)))

# Calculate and display volatility
volatility = calculate_historical_volatility(mock_prices, lookback_period=20, annualize=True)
print(f"Mock Prices (last 5):\n{mock_prices.tail()}")
print(f"Calculated Annualized Volatility (20-day lookback): {volatility:.4f}")

# Demonstrate rolling volatility
mock_returns = np.log(mock_prices / mock_prices.shift(1)).dropna()
rolling_vol = mock_returns.rolling(window=20).std() * np.sqrt(252)

plt.figure(figsize=(12, 6))
plt.plot(mock_prices.index, mock_prices, label='Asset Price')
plt.title('Mock Asset Price Over Time')
plt.xlabel('Time Step')
plt.ylabel('Price')
plt.grid(True)
plt.legend()
plt.show()

plt.figure(figsize=(12, 6))
plt.plot(rolling_vol.index, rolling_vol, label='Annualized Rolling 20-day Volatility', color='orange')
plt.title('Rolling Historical Volatility of Mock Asset')
plt.xlabel('Time Step')
plt.ylabel('Volatility')
plt.grid(True)
plt.legend()
plt.show()

def calculate_volatility_based_position_size(
    account_capital,
    risk_percentage_per_trade,
    asset_prices,
    lookback_period=20,
    stop_loss_multiplier=1 # How many 'volatility units' away is your stop loss
):
    """
    Calculates the number of units to trade using a volatility-based sizing approach.

    Inputs:
    - account_capital (float): Total trading capital.
    - risk_percentage_per_trade (float): Percentage of capital to risk per trade (e.g., 0.01 for 1%).
    - asset_prices (pd.Series): A series of asset closing prices.
    - lookback_period (int): Lookback period for calculating daily volatility.
    - stop_loss_multiplier (float): Multiplier to relate volatility to the stop-loss distance.
      For example, if your stop-loss is typically set at 2 times the daily standard deviation
      of price movement, this would be 2.

    Outputs:
    - int: The calculated number of units (shares/contracts) to trade.

    Formulas:
    1. Maximum Dollar Risk Per Trade = `account_capital * risk_percentage_per_trade`
    2. Daily Dollar Volatility = `daily_std_of_returns * current_price`
    3. Risk per Unit = `Daily Dollar Volatility * stop_loss_multiplier`
    4. Number of Units = `Maximum Dollar Risk Per Trade / Risk per Unit`
    """
    if len(asset_prices) < lookback_period + 1:
        return 0 # Not enough data to calculate volatility

    current_price = asset_prices.iloc[-1]

    # Calculate daily returns for the lookback period
    returns = np.log(asset_prices / asset_prices.shift(1)).dropna()

    if len(returns) < lookback_period:
        return 0

    # Calculate the daily standard deviation of returns
    daily_std_returns = returns.rolling(window=lookback_period).std().iloc[-1]

    # Convert daily standard deviation of returns to daily dollar volatility
    # This represents the expected 1-standard deviation dollar movement per day.
    daily_dollar_volatility = daily_std_returns * current_price

    if daily_dollar_volatility <= 0:
        return 0 # Avoid division by zero or negative volatility

    # Calculate maximum dollar risk per trade
    max_dollar_risk_per_trade = account_capital * risk_percentage_per_trade

    # Estimate the dollar risk per unit (share) based on volatility and stop loss placement.
    # If your stop loss is set at 'stop_loss_multiplier' times the daily dollar volatility,
    # then this is your 'risk per unit' for sizing purposes.
    risk_per_unit = daily_dollar_volatility * stop_loss_multiplier

    if risk_per_unit <= 0:
        return 0

    # Calculate the number of units
    number_of_units = max_dollar_risk_per_trade / risk_per_unit

    return int(round(number_of_units))

# --- Simulation Parameters ---
np.random.seed(42) # for reproducibility
num_days = 252 # One trading year
initial_price = 100
account_capital = 100000 # $100,000
risk_percentage_per_trade = 0.01 # 1% risk per trade
lookback_period_vol = 20 # 20-day lookback for volatility
stop_loss_multiplier = 2 # Stop loss at 2x daily dollar volatility

# --- Generate Mock Price Data with Changing Volatility ---
# We'll simulate periods of low and high volatility
price_data = [initial_price]
current_price = initial_price

for i in range(1, num_days):
    # Simulate changing volatility
    if i < num_days / 3:
        daily_std = 0.5 # Lower volatility
    elif i < 2 * num_days / 3:
        daily_std = 1.5 # Higher volatility
    else:
        daily_std = 0.8 # Medium volatility

    # Simulate price movement
    price_change = np.random.normal(0, daily_std)
    current_price += price_change
    price_data.append(current_price)

mock_prices_df = pd.Series(price_data, name='Price')

# --- Calculate Rolling Volatility and Position Size ---
position_sizes = []
rolling_dollar_volatilities = []

for i in range(lookback_period_vol, num_days):
    current_prices_window = mock_prices_df.iloc[:i+1]

    # Calculate daily standard deviation of returns for the rolling window
    current_returns_window = np.log(current_prices_window / current_prices_window.shift(1)).dropna()
    if len(current_returns_window) >= lookback_period_vol:
        daily_std_returns = current_returns_window.rolling(window=lookback_period_vol).std().iloc[-1]
        current_price_for_calc = current_prices_window.iloc[-1]
        daily_dollar_vol = daily_std_returns * current_price_for_calc
        rolling_dollar_volatilities.append(daily_dollar_vol)
    else:
        daily_dollar_vol = np.nan # Not enough data yet
        rolling_dollar_volatilities.append(np.nan)

    size = calculate_volatility_based_position_size(
        account_capital,
        risk_percentage_per_trade,
        current_prices_window,
        lookback_period=lookback_period_vol,
        stop_loss_multiplier=stop_loss_multiplier
    )
    position_sizes.append(size)

# Align position_sizes and rolling_dollar_volatilities with the original index for plotting
# The first `lookback_period_vol` days won't have a position size or rolling vol
index_start = mock_prices_df.index[lookback_period_vol]
position_sizes_series = pd.Series(position_sizes, index=mock_prices_df.index[lookback_period_vol:])
# FIX: Removed the slicing for rolling_dollar_volatilities as it already has the correct length
rolling_dollar_volatilities_series = pd.Series(rolling_dollar_volatilities, index=mock_prices_df.index[lookback_period_vol:])

print("\n--- Simulation Results (last 10 days) ---")
results_df = pd.DataFrame({
    'Price': mock_prices_df,
    'Rolling Dollar Volatility': rolling_dollar_volatilities_series,
    'Calculated Position Size': position_sizes_series
}).tail(10)

print(results_df.to_markdown())

import matplotlib.pyplot as plt

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

ax1.plot(mock_prices_df.index, mock_prices_df, label='Asset Price', color='blue')
ax1.set_xlabel('Time Step')
ax1.set_ylabel('Asset Price', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')
ax1.grid(True, linestyle='--', alpha=0.7)

ax2 = ax1.twinx()
ax2.plot(rolling_dollar_volatilities_series.index, rolling_dollar_volatilities_series, label='Rolling Daily Dollar Volatility', color='red', linestyle='--')
ax2.set_ylabel('Daily Dollar Volatility', color='red')
ax2.tick_params(axis='y', labelcolor='red')

plt.title('Asset Price and Rolling Daily Dollar Volatility Over Time')
fig.tight_layout()
plt.legend(loc='upper left', bbox_to_anchor=(0.0, 0.95))
plt.show()

import matplotlib.pyplot as plt

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

ax1.plot(rolling_dollar_volatilities_series.index, rolling_dollar_volatilities_series, label='Rolling Daily Dollar Volatility', color='red')
ax1.set_xlabel('Time Step')
ax1.set_ylabel('Daily Dollar Volatility', color='red')
ax1.tick_params(axis='y', labelcolor='red')
ax1.grid(True, linestyle='--', alpha=0.7)

ax2 = ax1.twinx()
ax2.plot(position_sizes_series.index, position_sizes_series, label='Calculated Position Size (Units)', color='green', linestyle='-')
ax2.set_ylabel('Calculated Position Size (Units)', color='green')
ax2.tick_params(axis='y', labelcolor='green')

plt.title('Rolling Daily Dollar Volatility vs. Calculated Volatility-Based Position Size')
fig.tight_layout()
plt.legend(loc='upper right', bbox_to_anchor=(1.0, 0.95))
plt.show()

print("\n--- Demonstrating Volatility Calculation for Crypto (365-day annualization) ---")
# Generate mock price data for a crypto asset (e.g., Bitcoin)
np.random.seed(43) # Another seed for different data
crypto_prices = pd.Series(50000 + np.cumsum(np.random.normal(0, 1000, 100))) # Higher price, different std

# Calculate and display volatility with 365 annualization factor
crypto_volatility = calculate_historical_volatility(crypto_prices, lookback_period=20, annualize=True, annualization_factor=365)
print(f"Mock Crypto Prices (last 5):\n{crypto_prices.tail()}")
print(f"Calculated Annualized Volatility (20-day lookback, 365-day factor): {crypto_volatility:.4f}")

# Visualize the crypto price and its rolling volatility
crypto_returns = np.log(crypto_prices / crypto_prices.shift(1)).dropna()
crypto_rolling_vol = crypto_returns.rolling(window=20).std() * np.sqrt(365)

plt.figure(figsize=(12, 6))
plt.plot(crypto_prices.index, crypto_prices, label='Crypto Asset Price', color='purple')
plt.title('Mock Crypto Asset Price Over Time')
plt.xlabel('Time Step')
plt.ylabel('Price')
plt.grid(True)
plt.legend()
plt.show()

plt.figure(figsize=(12, 6))
plt.plot(crypto_rolling_vol.index, crypto_rolling_vol, label='Annualized Rolling 20-day Volatility (Crypto)', color='orange')
plt.title('Rolling Historical Volatility of Mock Crypto Asset')
plt.xlabel('Time Step')
plt.ylabel('Volatility')
plt.grid(True)
plt.legend()
plt.show()