# Thư viện cần cài đặt
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import yfinance as yf
import scipy.optimize as sco
from scipy import stats
import cvxpy as cp
import warnings

# Thiết lập hiển thị
warnings.filterwarnings('ignore')
plt.style.use('fivethirtyeight')
np.random.seed(777)

def get_stock_data(tickers, start_date, end_date, interval='1d'):
    """
    Thu thập dữ liệu cổ phiếu từ Yahoo Finance
    
    Tham số:
    tickers (list): Danh sách mã cổ phiếu
    start_date (str): Ngày bắt đầu (YYYY-MM-DD)
    end_date (str): Ngày kết thúc (YYYY-MM-DD)
    interval (str): Khoảng thời gian ('1d', '1wk', '1mo')
    
    Trả về:
    pd.DataFrame: DataFrame chứa giá đóng cửa đã điều chỉnh của các cổ phiếu
    """
    data = yf.download(tickers, start=start_date, end=end_date, interval=interval)['Adj Close']
    
    # Xử lý trường hợp chỉ có một mã cổ phiếu
    if isinstance(data, pd.Series):
        data = pd.DataFrame(data)
        data.columns = [tickers]
    
    # Kiểm tra và xử lý dữ liệu thiếu
    if data.isnull().sum().sum() > 0:
        print(f"Có {data.isnull().sum().sum()} giá trị thiếu. Tiến hành điền giá trị thiếu...")
        data = data.fillna(method='ffill').fillna(method='bfill')
    
    return data

# Danh sách các mã cổ phiếu mẫu (đổi thành các mã trên HOSE nếu cần)
tickers = ['AAPL', 'MSFT', 'GOOG', 'AMZN', 'META', 'TSLA', 'NVDA', 'JPM', 'V', 'PG']

# Khoảng thời gian
start_date = '2018-01-01'
end_date = '2023-01-01'

# Thu thập dữ liệu
prices = get_stock_data(tickers, start_date, end_date)
print(prices.head())

# Vẽ biểu đồ giá cổ phiếu (chuẩn hóa)
normalized_prices = prices / prices.iloc[0] * 100
plt.figure(figsize=(12, 8))
normalized_prices.plot()
plt.title('Diễn biến giá cổ phiếu (chuẩn hóa)')
plt.xlabel('Ngày')
plt.ylabel('Giá chuẩn hóa (100 = giá ban đầu)')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()

def calculate_returns(prices, period='daily'):
    """
    Tính lợi nhuận của cổ phiếu
    
    Tham số:
    prices (pd.DataFrame): DataFrame chứa giá cổ phiếu
    period (str): Kỳ hạn lợi nhuận ('daily', 'weekly', 'monthly', 'annual')
    
    Trả về:
    pd.DataFrame: DataFrame chứa lợi nhuận
    """
    if period == 'daily':
        returns = prices.pct_change().dropna()
    elif period == 'weekly':
        returns = prices.resample('W').last().pct_change().dropna()
    elif period == 'monthly':
        returns = prices.resample('M').last().pct_change().dropna()
    elif period == 'annual':
        returns = prices.resample('Y').last().pct_change().dropna()
    else:
        raise ValueError("Kỳ hạn không hợp lệ. Sử dụng 'daily', 'weekly', 'monthly', hoặc 'annual'")
    
    return returns

# Tính lợi nhuận hàng ngày
daily_returns = calculate_returns(prices)

# Thống kê mô tả
desc_stats = daily_returns.describe().T
desc_stats['annualized_return'] = daily_returns.mean() * 252
desc_stats['annualized_vol'] = daily_returns.std() * np.sqrt(252)
desc_stats['sharpe_ratio'] = desc_stats['annualized_return'] / desc_stats['annualized_vol']

print(desc_stats[['mean', 'std', 'annualized_return', 'annualized_vol', 'sharpe_ratio']])

def plot_returns_distribution(returns):
    """
    Vẽ biểu đồ phân phối lợi nhuận
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    plt.figure(figsize=(15, 10))
    
    for i, ticker in enumerate(returns.columns):
        plt.subplot(3, 4, i+1)
        
        # Histogram
        sns.histplot(returns[ticker], kde=True, stat="density", linewidth=0)
        
        # Normal distribution curve
        xmin, xmax = plt.xlim()
        x = np.linspace(xmin, xmax, 100)
        p = stats.norm.pdf(x, returns[ticker].mean(), returns[ticker].std())
        plt.plot(x, p, 'k', linewidth=2)
        
        plt.title(f'Phân phối lợi nhuận {ticker}')
        plt.xlabel('Lợi nhuận hàng ngày')
        plt.ylabel('Mật độ')
    
    plt.tight_layout()

def calculate_risk_metrics(returns, risk_free_rate=0.0):
    """
    Tính toán các thước đo rủi ro cho từng cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_free_rate (float): Lãi suất phi rủi ro (annualized)
    
    Trả về:
    pd.DataFrame: DataFrame chứa các thước đo rủi ro
    """
    # Chuyển đổi lãi suất phi rủi ro sang tỷ lệ hàng ngày
    daily_rf = (1 + risk_free_rate) ** (1/252) - 1
    
    # DataFrame để lưu kết quả
    metrics = pd.DataFrame(index=returns.columns)
    
    # Độ biến động (Volatility) hàng năm
    metrics['volatility'] = returns.std() * np.sqrt(252)
    
    # Tỷ lệ Sharpe
    excess_returns = returns.sub(daily_rf, axis=0)
    metrics['sharpe_ratio'] = (excess_returns.mean() * 252) / metrics['volatility']
    
    # Maximum Drawdown
    cumulative_returns = (1 + returns).cumprod()
    rolling_max = cumulative_returns.cummax()
    drawdown = (cumulative_returns - rolling_max) / rolling_max
    metrics['max_drawdown'] = drawdown.min()
    
    # Value at Risk (VaR) 95%
    metrics['var_95'] = returns.quantile(0.05)
    
    # Conditional Value at Risk (CVaR) 95%
    metrics['cvar_95'] = returns[returns < returns.quantile(0.05)].mean()
    
    # Tỷ lệ Sortino
    negative_returns = returns.copy()
    negative_returns[negative_returns > 0] = 0
    downside_deviation = negative_returns.std() * np.sqrt(252)
    metrics['sortino_ratio'] = (excess_returns.mean() * 252) / downside_deviation
    
    # Beta (so với chỉ số S&P 500)
    sp500 = yf.download('^GSPC', start=returns.index[0], end=returns.index[-1], interval='1d')['Adj Close']
    sp500_returns = sp500.pct_change().dropna()
    
    # Chỉ lấy những ngày trùng khớp
    common_index = returns.index.intersection(sp500_returns.index)
    returns_aligned = returns.loc[common_index]
    sp500_returns_aligned = sp500_returns.loc[common_index]
    
    # Tính beta
    for ticker in returns.columns:
        covariance = np.cov(returns_aligned[ticker], sp500_returns_aligned)[0, 1]
        variance = np.var(sp500_returns_aligned)
        metrics.loc[ticker, 'beta'] = covariance / variance
    
    return metrics

def plot_risk_return(returns, risk_metrics, period=252):
    """
    Vẽ biểu đồ rủi ro-lợi nhuận
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    risk_metrics (pd.DataFrame): DataFrame chứa các thước đo rủi ro
    period (int): Số ngày trong một năm để annualize lợi nhuận
    """
    plt.figure(figsize=(12, 8))
    
    # Tính lợi nhuận trung bình hàng năm
    annual_returns = returns.mean() * period
    
    # Biểu đồ scatter
    plt.scatter(risk_metrics['volatility'], annual_returns, s=200, alpha=0.6)
    
    # Thêm nhãn
    for i, ticker in enumerate(returns.columns):
        plt.annotate(ticker, 
                     (risk_metrics['volatility'][i], annual_returns[i]),
                     xytext=(10, 5),
                     textcoords='offset points',
                     fontsize=12)
    
    # Thêm title và label
    plt.title('Biểu đồ Rủi ro - Lợi nhuận', fontsize=16)
    plt.xlabel('Rủi ro (Độ biến động hàng năm)', fontsize=14)
    plt.ylabel('Lợi nhuận kỳ vọng hàng năm', fontsize=14)
    
    # Thêm đường Linear Regression
    z = np.polyfit(risk_metrics['volatility'], annual_returns, 1)
    p = np.poly1d(z)
    plt.plot(risk_metrics['volatility'], p(risk_metrics['volatility']), "r--", linewidth=2)
    
    plt.tight_layout()

def plot_drawdown(returns):
    """
    Vẽ biểu đồ drawdown cho từng cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    plt.figure(figsize=(12, 8))
    
    for ticker in returns.columns:
        # Tính cumulative returns
        cumulative_returns = (1 + returns[ticker]).cumprod()
        
        # Tính rolling maximum
        rolling_max = cumulative_returns.cummax()
        
        # Tính drawdown
        drawdown = (cumulative_returns - rolling_max) / rolling_max
        
        # Vẽ drawdown
        plt.plot(drawdown, label=ticker)
    
    plt.title('Biểu đồ Drawdown', fontsize=16)
    plt.xlabel('Ngày', fontsize=14)
    plt.ylabel('Drawdown', fontsize=14)
    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
    plt.tight_layout()

def plot_correlation_matrix(returns):
    """
    Vẽ ma trận tương quan giữa các cổ phiếu
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    """
    # Tính ma trận tương quan
    corr_matrix = returns.corr()
    
    # Thiết lập kích thước biểu đồ
    plt.figure(figsize=(10, 8))
    
    # Vẽ heatmap
    cmap = sns.diverging_palette(220, 10, as_cmap=True)
    sns.heatmap(corr_matrix, annot=True, cmap=cmap, center=0,
                square=True, linewidths=.5, cbar_kws={"shrink": .8})
    
    plt.title('Ma trận tương quan giữa các cổ phiếu', fontsize=16)
    plt.tight_layout()

def calculate_portfolio_performance(weights, returns):
    """
    Tính toán hiệu suất của danh mục đầu tư
    
    Tham số:
    weights (np.array): Trọng số phân bổ cho từng cổ phiếu
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    
    Trả về:
    tuple: (lợi nhuận kỳ vọng, độ biến động, tỷ lệ Sharpe)
    """
    # Lợi nhuận danh mục
    portfolio_return = np.sum(returns.mean() * weights) * 252
    
    # Độ biến động danh mục
    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))
    
    # Tỷ lệ Sharpe
    sharpe_ratio = portfolio_return / portfolio_volatility
    
    return portfolio_return, portfolio_volatility, sharpe_ratio

def random_portfolios(returns, num_portfolios=10000):
    """
    Tạo ngẫu nhiên các danh mục đầu tư và tính hiệu suất
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    num_portfolios (int): Số lượng danh mục ngẫu nhiên cần tạo
    
    Trả về:
    tuple: (results, weights) - kết quả hiệu suất và trọng số tương ứng
    """
    results = np.zeros((num_portfolios, 3))
    weights_record = np.zeros((num_portfolios, len(returns.columns)))
    
    for i in range(num_portfolios):
        # Tạo trọng số ngẫu nhiên
        weights = np.random.random(len(returns.columns))
        weights /= np.sum(weights)
        weights_record[i, :] = weights
        
        # Tính hiệu suất
        results[i, 0], results[i, 1], results[i, 2] = calculate_portfolio_performance(weights, returns)
    
    return results, weights_record

def plot_efficient_frontier(returns, results, weights_record):
    """
    Vẽ biểu đồ đường biên hiệu quả
    
    Tham số:
    returns (pd.DataFrame): DataFrame chứa lợi nhuận
    results (np.array): Mảng kết quả hiệu suất của các danh mục ngẫu nhiên
    weights_record (np.array): Mảng trọng số của các danh mục ngẫu nhiên
    """
    plt.figure(figsize=(12, 8))
    
    # Vẽ các danh mục ngẫu nhiên
    plt.scatter(results[:, 1], results[:, 0], c=results[:, 2], 
                cmap='viridis', marker='o', s=10, alpha=0.3)
    
    # Đánh dấu danh mục có Sharpe ratio cao nhất
    max_sharpe_idx = np.argmax(results[:, 2])
    max_sharpe_portfolio = results[max_sharpe_idx]
    plt.scatter(max_sharpe_portfolio[1], max_sharpe_portfolio[0],
                marker='*', color='r', s=500, label='Danh mục tối ưu theo Sharpe')
    
    # Đánh dấu danh mục có độ biến động thấp nhất
    min_vol_idx = np.argmin(results[:, 1])
    min_vol_portfolio = results[min_vol_idx]
    plt.scatter(min_vol_portfolio[1], min_vol_portfolio[0],
                marker='*', color='g', s=500, label='Danh mục có độ biến động thấp nhất')
    
    # Đánh dấu cổ phiếu riêng lẻ
    for i, ticker in enumerate(returns.columns):
        individual_return = returns.mean()[i] * 252
        individual_volatility = returns.std()[i] * np.sqrt(252)
        plt.scatter(individual_volatility, individual_return, marker='o', s=200,
                   color='black', label=ticker if i == 0 else "")
        plt.annotate(ticker, (individual_volatility, individual_return),
                    xytext=(10, 5), textcoords='offset points')
    
    # Thêm title và label
    plt.colorbar(label='Sharpe ratio')
    plt.title('Đường biên hiệu quả (Efficient Frontier)', fontsize=16)
    plt.xlabel('Độ biến động (Rủi ro)', fontsize=14)
    plt.ylabel('Lợi nhuận kỳ vọng', fontsize=14)
    plt.legend()
    
    # Hiển thị thông tin về danh mục tối ưu
    print("Danh mục tối ưu theo tỷ lệ Sharpe:")
    print(f"Lợi nhuận kỳ vọng: {max_sharpe_portfolio[0]:.4f}")
    print(f"Độ biến động: {max_sharpe_portfolio[1]:.4f}")
    print(f"Tỷ lệ Sharpe: {max_sharpe_portfolio[2]:.4f}")
    print("\nPhân bổ vốn:")
    for i, ticker in enumerate(returns.columns):
        print(f"{ticker}: {weights_record[max_sharpe_idx, i] * 100:.2f}%")
    
    plt.tight_layout()