import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

# Load stock data (in practice, you can obtain this from APIs like Yahoo Finance)
# df = pd.read_csv('stock_data.csv')

# Create sample data
np.random.seed(42)  # Set random seed for reproducibility
date_range = pd.date_range(start='2024-01-01', end='2025-01-01', freq='B')
n = len(date_range)

# Generate normal price and volume data
closing_price = 100 + np.cumsum(np.random.randn(n))
volume = np.random.normal(500000, 100000, n)  # Normal distribution with mean 500000 and standard deviation 100000
volume = np.abs(volume).astype(int)  # Ensure volume is positive

# Artificially add some volume anomalies
num_anomalies = 10
anomaly_indices = np.random.choice(n, num_anomalies, replace=False)
for i in anomaly_indices:
    # Randomly decide whether to amplify or reduce volume
    if np.random.rand() > 0.5:
        volume[i] = volume[i] * 3  # Amplify volume by 3x
    else:
        volume[i] = volume[i] // 5  # Reduce volume to 1/5

# Create DataFrame
df = pd.DataFrame({
    'Date': date_range,
    'Close': closing_price,
    'Volume': volume
})

# Calculate 5-day average volume
df['Volume_MA5'] = df['Volume'].rolling(window=5).mean()

# Use Z-score method to detect volume anomalies
# Z-score represents the number of standard deviations a data point is from the mean
window_size = 20  # Window size for calculating Z-score
df['Volume_Zscore'] = df['Volume'].rolling(window=window_size).apply(
    lambda x: (x[-1] - x.mean()) / x.std() if x.std() > 0 else 0
)

# Set anomaly threshold, usually 2 or 3 standard deviations
z_threshold = 2
df['Volume_Anomaly'] = np.abs(df['Volume_Zscore']) > z_threshold

# Use box plot method to detect outliers (another common method)
q1 = df['Volume'].rolling(window=window_size).quantile(0.25)
q3 = df['Volume'].rolling(window=window_size).quantile(0.75)
iqr = q3 - q1
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr
df['Volume_Outlier'] = (df['Volume'] < lower_bound) | (df['Volume'] > upper_bound)

# Visualize results
plt.figure(figsize=(14, 8))

# Plot price trend
plt.subplot(3, 1, 1)
plt.plot(df['Date'], df['Close'])
plt.title('Price Trend')
plt.ylabel('Price')

# Plot volume chart and mark anomalies
plt.subplot(3, 1, 2)
plt.bar(df['Date'], df['Volume'], label='Volume')
plt.plot(df['Date'], df['Volume_MA5'], color='red', label='5-Day Average Volume')
# Mark Z-score anomalies
anomaly_dates = df[df['Volume_Anomaly']]['Date']
anomaly_volumes = df[df['Volume_Anomaly']]['Volume']
plt.scatter(anomaly_dates, anomaly_volumes, color='purple', marker='o', s=100, label='Z-score Anomaly')
plt.title('Volume and Anomaly Detection')
plt.ylabel('Volume')
plt.legend()

# Plot Z-score chart
plt.subplot(3, 1, 3)
plt.plot(df['Date'], df['Volume_Zscore'])
plt.axhline(y=z_threshold, color='r', linestyle='--', label=f'Upper Threshold ({z_threshold})')
plt.axhline(y=-z_threshold, color='r', linestyle='--', label=f'Lower Threshold ({-z_threshold})')
plt.title('Volume Z-score')
plt.ylabel('Z-score')
plt.legend()

plt.tight_layout()
plt.show()

# Output detected anomaly dates
print("Detected Volume Anomaly Dates:")
anomaly_data = df[df['Volume_Anomaly']][['Date', 'Volume', 'Volume_MA5', 'Volume_Zscore']]
print(anomaly_data)

# Calculate anomaly detection statistics
print(f"\nTotal Trading Days: {n}")
print(f"Detected Anomaly Days: {len(anomaly_data)}")
print(f"Anomaly Day Percentage: {len(anomaly_data)/n:.2%}")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import yfinance as yf  # Need to install yfinance library: pip install yfinance
from datetime import datetime, timedelta

# Download stock data
def download_stock_data(ticker, start_date, end_date):
    try:
        data = yf.download(ticker, start=start_date, end=end_date)
        return data
    except Exception as e:
        print(f"Error downloading data: {e}")
        # If download fails, return simulated data
        date_range = pd.date_range(start=start_date, end=end_date, freq='B')
        n = len(date_range)
        closing_price = 100 + np.cumsum(np.random.randn(n))
        data = pd.DataFrame({
            'Close': closing_price
        }, index=date_range)
        return data

# Calculate daily returns
def calculate_daily_returns(data):
    data['Daily_Return'] = data['Close'].pct_change()
    return data

# Calculate VaR (historical simulation method)
def calculate_var(returns, confidence_level=0.95, holding_period=1):
    # Remove NaN values
    clean_returns = returns.dropna()
    
    # Calculate quantile (VaR value is negative, indicating potential loss)
    var = np.percentile(clean_returns, (1 - confidence_level) * 100)
    
    # For holding periods longer than 1 day, assume returns follow normal distribution and adjust using time square root rule
    if holding_period > 1:
        var = var * np.sqrt(holding_period)
    
    return var

# Calculate CVaR (Conditional Value at Risk)
def calculate_cvar(returns, confidence_level=0.95):
    clean_returns = returns.dropna()
    var = np.percentile(clean_returns, (1 - confidence_level) * 100)
    cvar = clean_returns[clean_returns <= var].mean()
    return cvar

# Visualize VaR results
def plot_var_results(returns, var_95, var_99, cvar_95):
    plt.figure(figsize=(12, 6))
    
    # Plot return distribution histogram
    plt.hist(returns.dropna(), bins=50, density=True, alpha=0.6, color='blue', label='Daily Return Distribution')
    
    # Add VaR and CVaR markers
    plt.axvline(x=var_95, color='red', linestyle='--', label=f'95% VaR: {var_95:.4f}')
    plt.axvline(x=var_99, color='purple', linestyle='--', label=f'99% VaR: {var_99:.4f}')
    plt.axvline(x=cvar_95, color='orange', linestyle='-', label=f'95% CVaR: {cvar_95:.4f}')
    
    plt.title('Return Distribution and VaR Analysis')
    plt.xlabel('Daily Return')
    plt.ylabel('Frequency')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.show()

# Main function
def main():
    # Set parameters
    ticker = "AAPL"  # Stock ticker, using Apple Inc. as an example here
    end_date = datetime.now()
    start_date = end_date - timedelta(days=365*3)  # Download data for the past 3 years
    confidence_level_95 = 0.95  # 95% confidence level
    confidence_level_99 = 0.99  # 99% confidence level
    holding_period = 1  # Holding period is 1 day
    
    # Download data
    print(f"Downloading historical data for {ticker}...")
    data = download_stock_data(ticker, start_date, end_date)
    
    # Calculate daily returns
    data = calculate_daily_returns(data)
    
    # Calculate VaR and CVaR
    var_95 = calculate_var(data['Daily_Return'], confidence_level_95, holding_period)
    var_99 = calculate_var(data['Daily_Return'], confidence_level_99, holding_period)
    cvar_95 = calculate_cvar(data['Daily_Return'], confidence_level_95)
    
    # Print results
    print(f"\nValue at Risk (VaR) Analysis Results:")
    print(f"1-day VaR at 95% confidence level: {var_95:.4f} (indicating a 5% probability of loss exceeding {abs(var_95)*100:.2f}%)")
    print(f"1-day VaR at 99% confidence level: {var_99:.4f} (indicating a 1% probability of loss exceeding {abs(var_99)*100:.2f}%)")
    print(f"1-day CVaR at 95% confidence level: {cvar_95:.4f} (indicating average loss of {abs(cvar_95)*100:.2f}% when exceeding VaR)")
    
    # Visualize results
    plot_var_results(data['Daily_Return'], var_95, var_99, cvar_95)
    
    # Calculate number of days actual loss exceeded VaR (backtesting)
    exceed_95 = data[data['Daily_Return'] < var_95]
    exceed_99 = data[data['Daily_Return'] < var_99]
    
    print(f"\nBacktesting Results:")
    print(f"Total Trading Days: {len(data['Daily_Return'].dropna())}")
    print(f"Days exceeding 95% VaR: {len(exceed_95)} ({len(exceed_95)/len(data['Daily_Return'].dropna())*100:.2f}%)")
    print(f"Days exceeding 99% VaR: {len(exceed_99)} ({len(exceed_99)/len(data['Daily_Return'].dropna())*100:.2f}%)")

if __name__ == "__main__":
    main()