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

def calculate_max_drawdown(price_series: pd.Series) -> tuple[float, pd.Series]:
    """
    Calculates the maximum drawdown for a given price series.

    Args:
        price_series (pd.Series): A pandas Series representing the historical prices of an asset or portfolio.

    Returns:
        tuple[float, pd.Series]: A tuple containing:
            - float: The maximum drawdown as a negative percentage.
            - pd.Series: A Series of cumulative drawdowns over time.

    Explanation:
    1.  **Cumulative Maximum**: Tracks the highest price reached so far.
    2.  **Drawdown**: Calculates the percentage drop from the cumulative maximum at each point.
    3.  **Max Drawdown**: Finds the largest (most negative) drawdown value.
    """
    if price_series.empty:
        return 0.0, pd.Series(dtype=float)

    cumulative_max = price_series.cummax()
    drawdown = (price_series - cumulative_max) / cumulative_max
    max_drawdown_value = drawdown.min() # The most negative drawdown

    return max_drawdown_value, drawdown

# --- Demonstration ---
# Generate a sample price series
np.random.seed(42)
initial_price = 100
returns = np.random.normal(loc=0.0005, scale=0.01, size=250) # Daily returns
price_series = pd.Series(initial_price * (1 + returns).cumprod())

print("Sample Price Series Head:")
print(price_series.head())

max_dd, drawdowns = calculate_max_drawdown(price_series)

print(f"\nCalculated Max Drawdown: {max_dd:.2%}")

# Visualize the price series and its drawdowns
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)

ax1.plot(price_series, label='Price Series', color='blue')
ax1.set_title('Asset Price Series')
ax1.set_ylabel('Price')
ax1.grid(True, linestyle='--', alpha=0.6)
ax1.legend()

ax2.plot(drawdowns, label='Drawdown from Peak', color='red')
ax2.axhline(max_dd, color='black', linestyle='--', label=f'Max Drawdown ({max_dd:.2%})')
ax2.fill_between(drawdowns.index, drawdowns, 0, where=(drawdowns < 0), color='red', alpha=0.3)
ax2.set_title('Drawdown Over Time')
ax2.set_xlabel('Time (Days)')
ax2.set_ylabel('Drawdown (%)')
ax2.ticklabel_format(style='plain', axis='y') # Prevent scientific notation
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: f'{y:.0%}'))
ax2.grid(True, linestyle='--', alpha=0.6)
ax2.legend()

plt.tight_layout()
plt.show()

def simulate_prices(initial_price: float = 100, num_days: int = 250, mu: float = 0.0005, sigma: float = 0.01, seed: int = 42) -> pd.Series:
    """
    Simulates a price series using a geometric Brownian motion model.

    Args:
        initial_price (float): The starting price of the asset.
        num_days (int): The number of days to simulate.
        mu (float): The mean of the daily returns (drift).
        sigma (float): The standard deviation of the daily returns (volatility).
        seed (int): Random seed for reproducibility.

    Returns:
        pd.Series: A pandas Series containing the simulated price path.
    """
    np.random.seed(seed)
    returns = np.random.normal(loc=mu, scale=sigma, size=num_days)
    price_path = pd.Series(initial_price * (1 + returns).cumprod())
    return price_path


def apply_max_drawdown_circuit_breaker(price_series: pd.Series, drawdown_threshold: float) -> tuple[pd.Series, pd.Series]:
    """
    Applies a max drawdown circuit breaker to a price series. Once the drawdown
    threshold is breached, the price series remains flat (representing halting
    of losses) for the remainder of the period.

    Args:
        price_series (pd.Series): The original price series.
        drawdown_threshold (float): The maximum allowed drawdown as a negative
                                    decimal (e.g., -0.10 for 10% drawdown).

    Returns:
        tuple[pd.Series, pd.Series]: A tuple containing:
            - pd.Series: The modified price series after applying the circuit breaker.
            - pd.Series: A boolean Series indicating when the circuit breaker was active.

    Explanation:
    1.  **Track Peak**: Keeps track of the highest price encountered so far.
    2.  **Calculate Current Drawdown**: At each step, calculate the drawdown from the current peak.
    3.  **Check Threshold**: If current drawdown exceeds `drawdown_threshold`:
        *   The circuit breaker is triggered.
        *   The price is capped at the level it was when the threshold was breached.
        *   No further price changes are allowed for the modified series.
    """
    modified_prices = price_series.copy()
    circuit_breaker_triggered = pd.Series(False, index=price_series.index)
    current_peak = -np.inf
    trigger_price = 0.0
    triggered = False

    for i in range(len(price_series)):
        current_price = price_series.iloc[i]

        if not triggered:
            # Update peak if current price is higher
            if current_price > current_peak:
                current_peak = current_price

            # Calculate current drawdown from the latest peak
            current_drawdown = (current_price - current_peak) / current_peak

            # Check if circuit breaker threshold is breached
            if current_drawdown <= drawdown_threshold:
                triggered = True
                trigger_price = current_price # Lock in the price at trigger point
                circuit_breaker_triggered.iloc[i:] = True # Mark as triggered from this point forward

        if triggered:
            modified_prices.iloc[i] = trigger_price # Cap prices at the trigger level

    return modified_prices, circuit_breaker_triggered

# --- Demonstration ---
# Simulate a new price series that will likely hit a drawdown
price_series_demo = simulate_prices(initial_price=100, num_days=250, mu=-0.001, sigma=0.02, seed=10)

drawdown_limit = -0.10 # 10% drawdown

modified_prices_cb, cb_active = apply_max_drawdown_circuit_breaker(price_series_demo, drawdown_limit)

print(f"Original Price Series Max Drawdown: {calculate_max_drawdown(price_series_demo)[0]:.2%}")
print(f"Modified Price Series Max Drawdown (with CB): {calculate_max_drawdown(modified_prices_cb)[0]:.2%}")

# Visualize the effect of the circuit breaker
fig, ax = plt.subplots(figsize=(14, 7))
ax.plot(price_series_demo, label='Original Price Series', color='blue', alpha=0.7)
ax.plot(modified_prices_cb, label=f'Price Series with CB (Threshold: {drawdown_limit:.0%})', color='green', linestyle='--')

# Highlight when the circuit breaker was active
if cb_active.any():
    trigger_point = cb_active.idxmax() # First day it was active
    ax.axvline(x=trigger_point, color='red', linestyle=':', label='Circuit Breaker Triggered')
    ax.fill_between(cb_active.index, ax.get_ylim()[0], ax.get_ylim()[1], where=cb_active, color='red', alpha=0.1, label='CB Active Period')

ax.set_title('Impact of Max Drawdown Circuit Breaker on Price Series')
ax.set_xlabel('Time (Days)')
ax.set_ylabel('Price')
ax.grid(True, linestyle='--', alpha=0.6)
ax.legend()
plt.tight_layout()
plt.show()

def plot_drawdowns_with_circuit_breaker(price_series: pd.Series, drawdown_threshold: float):
    """
    Plots the drawdowns from peak and highlights when a circuit breaker would trigger.

    Args:
        price_series (pd.Series): The original price series.
        drawdown_threshold (float): The max allowed drawdown as a negative decimal.
    """
    _, drawdowns = calculate_max_drawdown(price_series)

    # Identify trigger points
    trigger_points = drawdowns[drawdowns <= drawdown_threshold]

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

    ax.plot(drawdowns, label='Drawdown from Peak', color='red', alpha=0.7)
    ax.axhline(0, color='grey', linestyle='-', linewidth=0.8)
    ax.axhline(drawdown_threshold, color='purple', linestyle='--', label=f'Circuit Breaker Threshold ({drawdown_threshold:.0%})')

    if not trigger_points.empty:
        # Plot individual trigger points
        ax.scatter(trigger_points.index, trigger_points.values, color='green', zorder=5, label='Trigger Points (Breached Threshold)')
        # Draw a shaded area from the first trigger point onwards
        first_trigger_index = trigger_points.index[0]
        ax.fill_between(drawdowns.index, drawdowns.min(), 0, where=(drawdowns.index >= first_trigger_index), color='green', alpha=0.1, label='CB Active Period')

    ax.set_title(f'Drawdown Profile with Max Drawdown Circuit Breaker (Threshold: {drawdown_threshold:.0%})')
    ax.set_xlabel('Time (Days)')
    ax.set_ylabel('Drawdown (%)')
    ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda y, _: f'{y:.0%}'))
    ax.grid(True, linestyle='--', alpha=0.6)
    ax.legend()
    plt.tight_layout()
    plt.show()

# --- Demonstration ---
plot_drawdowns_with_circuit_breaker(price_series_demo, drawdown_limit)

# Another example with a different threshold and simulation
print("\n--- Another Example ---")
price_series_example_2 = simulate_prices(initial_price=100, num_days=250, mu=0.0001, sigma=0.015, seed=7)
drawdown_limit_2 = -0.15 # 15% drawdown
plot_drawdowns_with_circuit_breaker(price_series_example_2, drawdown_limit_2)