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

class ExposureLimitManager:
    """
    A simplified class to manage and monitor risk exposures against defined limits.
    """
    def __init__(self, name="DefaultManager"):
        self.name = name
        self.exposure_limits = {}
        self.current_exposures = {}
        self.breaches = {}

    def define_limit(self, exposure_type: str, limit_value: float):
        """
        Defines a maximum limit for a specific exposure type.

        Args:
            exposure_type (str): The type of exposure (e.g., 'Market', 'Credit', 'Operational').
            limit_value (float): The maximum allowed value for this exposure type.
        """
        if limit_value < 0:
            raise ValueError("Limit value cannot be negative.")
        self.exposure_limits[exposure_type] = limit_value
        print(f"Limit for '{exposure_type}' set to {limit_value}.")

    def update_exposure(self, exposure_type: str, current_value: float):
        """
        Updates the current exposure for a given type and checks for breaches.

        Args:
            exposure_type (str): The type of exposure to update.
            current_value (float): The current measured value of the exposure.

        Outputs:
            bool: True if a breach occurred, False otherwise.
        """
        if exposure_type not in self.exposure_limits:
            print(f"Warning: No limit defined for '{exposure_type}'. Exposure updated but not monitored.")
            self.current_exposures[exposure_type] = current_value
            return False

        self.current_exposures[exposure_type] = current_value
        limit = self.exposure_limits[exposure_type]

        if current_value > limit:
            self.breaches[exposure_type] = True
            print(f"ALERT: {exposure_type} exposure ({current_value}) exceeds limit ({limit})!")
            return True
        else:
            self.breaches[exposure_type] = False
            # print(f"{exposure_type} exposure ({current_value}) is within limits.")
            return False

    def get_status(self):
        """
        Returns the current status of all monitored exposures and their limits.

        Outputs:
            dict: A dictionary containing exposure types, current values, limits, and breach status.
        """
        status = {}
        for exp_type, limit in self.exposure_limits.items():
            current_val = self.current_exposures.get(exp_type, 0.0)
            breached = self.breaches.get(exp_type, False)
            status[exp_type] = {
                'current_exposure': current_val,
                'limit': limit,
                'breached': breached
            }
        return status

    def get_breaches(self):
        """
        Returns a dictionary of all exposure types currently in breach.

        Outputs:
            dict: Exposure types that are currently breached with their current value and limit.
        """
        return {exp_type: self.get_status()[exp_type] for exp_type, data in self.get_status().items() if data['breached']}


# Instantiate the Exposure Limit Manager
manager = ExposureLimitManager("TradingDeskRiskManager")

# Define limits
manager.define_limit('Market Exposure', 1000000) # $1 Million limit
manager.define_limit('Credit Exposure', 500000)  # $500k limit
manager.define_limit('Operational Risk', 100000) # $100k limit

# Simulate exposure over 100 timesteps
time_steps = 100
dates = pd.to_datetime(pd.date_range(start='2023-01-01', periods=time_steps, freq='D'))

# Generate mock exposure data with some fluctuations and potential breaches
np.random.seed(42) # for reproducibility
market_exposures = np.cumsum(np.random.normal(0, 50000, time_steps)) + 500000
credit_exposures = np.cumsum(np.random.normal(0, 20000, time_steps)) + 200000
operational_exposures = np.cumsum(np.random.normal(0, 5000, time_steps)) + 50000

# Introduce some spikes to simulate breaches
market_exposures[30:35] += 600000
credit_exposures[60:65] += 400000

# Store historical data for plotting
history = []

for i in range(time_steps):
    # Update market exposure
    manager.update_exposure('Market Exposure', market_exposures[i])

    # Update credit exposure
    manager.update_exposure('Credit Exposure', credit_exposures[i])

    # Update operational risk (without breach simulation for simplicity)
    manager.update_exposure('Operational Risk', operational_exposures[i])

    history.append({
        'Date': dates[i],
        'Market Exposure': market_exposures[i],
        'Credit Exposure': credit_exposures[i],
        'Operational Risk': operational_exposures[i],
        'Market Limit': manager.exposure_limits['Market Exposure'],
        'Credit Limit': manager.exposure_limits['Credit Exposure'],
        'Operational Limit': manager.exposure_limits['Operational Risk'],
        'Market Breached': manager.breaches.get('Market Exposure', False),
        'Credit Breached': manager.breaches.get('Credit Exposure', False),
        'Operational Breached': manager.breaches.get('Operational Risk', False)
    })

history_df = pd.DataFrame(history)

print("\n--- Final Status ---")
display(manager.get_status())

print("\n--- Current Breaches ---")
display(manager.get_breaches())

fig1, axes = plt.subplots(2, 1, figsize=(14, 10), sharex=True)

# Plot Market Exposure
axes[0].plot(history_df['Date'], history_df['Market Exposure'], label='Market Exposure', color='blue')
axes[0].axhline(y=manager.exposure_limits['Market Exposure'], color='red', linestyle='--', label='Market Limit')
axes[0].fill_between(history_df['Date'], history_df['Market Exposure'], manager.exposure_limits['Market Exposure'],
                     where=(history_df['Market Exposure'] > manager.exposure_limits['Market Exposure']),
                     facecolor='red', alpha=0.3, interpolate=True, label='Breach')
axes[0].set_title('Market Exposure Over Time vs. Limit')
axes[0].set_ylabel('Exposure Value ($)')
axes[0].legend()
axes[0].grid(True, linestyle=':', alpha=0.7)

# Plot Credit Exposure
axes[1].plot(history_df['Date'], history_df['Credit Exposure'], label='Credit Exposure', color='green')
axes[1].axhline(y=manager.exposure_limits['Credit Exposure'], color='red', linestyle='--', label='Credit Limit')
axes[1].fill_between(history_df['Date'], history_df['Credit Exposure'], manager.exposure_limits['Credit Exposure'],
                     where=(history_df['Credit Exposure'] > manager.exposure_limits['Credit Exposure']),
                     facecolor='red', alpha=0.3, interpolate=True)
axes[1].set_title('Credit Exposure Over Time vs. Limit')
axes[1].set_xlabel('Date')
axes[1].set_ylabel('Exposure Value ($)')
axes[1].legend()
axes[1].grid(True, linestyle=':', alpha=0.7)

plt.tight_layout()
plt.show(fig1)

exposure_types = ['Market Exposure', 'Credit Exposure', 'Operational Risk']

avg_exposures = [history_df[col].mean() for col in exposure_types]
limits = [manager.exposure_limits[exp_type] for exp_type in exposure_types]

x = np.arange(len(exposure_types))
width = 0.35

fig2, ax = plt.subplots(figsize=(10, 6))
rects1 = ax.bar(x - width/2, avg_exposures, width, label='Average Exposure', color='skyblue')
rects2 = ax.bar(x + width/2, limits, width, label='Defined Limit', color='orange')

# Add labels, title, and custom x-axis tick labels
ax.set_ylabel('Value ($)')
ax.set_title('Average Exposure vs. Defined Limits by Type')
ax.set_xticks(x)
ax.set_xticklabels(exposure_types)
ax.legend()
ax.grid(axis='y', linestyle=':', alpha=0.7)

def autolabel(rects):
    """Attach a text label above each bar in *rects*, displaying its height."""
    for rect in rects:
        height = rect.get_height()
        ax.annotate(f'{height:,.0f}',
                    xy=(rect.get_x() + rect.get_width() / 2, height),
                    xytext=(0, 3),  # 3 points vertical offset
                    textcoords="offset points",
                    ha='center', va='bottom')

autolabel(rects1)
autolabel(rects2)

plt.tight_layout()
plt.show(fig2)