import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta

# Xác định khoảng thời gian
end_date = datetime.now()
start_date = end_date - timedelta(days=365*5)  # Lấy dữ liệu 5 năm

# Lấy dữ liệu cổ phiếu
ticker = "AAPL"  # Apple Inc.
data = yf.download(ticker, start=start_date, end=end_date)

# Xem dữ liệu
print(data.head())

# Xử lý giá trị thiếu
data = data.dropna()

# Thêm các chỉ báo kỹ thuật
# 1. Trung bình động (Moving Average)
data['MA20'] = data['Close'].rolling(window=20).mean()
data['MA50'] = data['Close'].rolling(window=50).mean()

# 2. MACD (Moving Average Convergence Divergence)
def calculate_macd(data, fast=12, slow=26, signal=9):
    data['EMA_fast'] = data['Close'].ewm(span=fast, adjust=False).mean()
    data['EMA_slow'] = data['Close'].ewm(span=slow, adjust=False).mean()
    data['MACD'] = data['EMA_fast'] - data['EMA_slow']
    data['MACD_signal'] = data['MACD'].ewm(span=signal, adjust=False).mean()
    data['MACD_histogram'] = data['MACD'] - data['MACD_signal']
    return data

data = calculate_macd(data)

# 3. RSI (Relative Strength Index)
def calculate_rsi(data, period=14):
    delta = data['Close'].diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    
    data['RSI'] = rsi
    return data

data = calculate_rsi(data)

# 4. Độ biến động (Volatility)
data['Volatility'] = data['Close'].pct_change().rolling(window=20).std() * np.sqrt(20)

# Loại bỏ các dòng chứa giá trị NaN sau khi tính toán
data = data.dropna()

print(data.head())

from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# Tính năng (features) và mục tiêu (target)
features = ['Open', 'High', 'Low', 'Volume', 'MA20', 'MA50', 'MACD', 'RSI', 'Volatility']
X = data[features]
y = data['Close']

# Chuẩn hóa dữ liệu
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Chia tập dữ liệu (80% training, 20% testing)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42, shuffle=False)

print(f"Kích thước tập huấn luyện: {X_train.shape}")
print(f"Kích thước tập kiểm tra: {X_test.shape}")

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Khởi tạo mô hình
model = LinearRegression()

# Huấn luyện mô hình
model.fit(X_train, y_train)

# Dự đoán trên tập kiểm tra
y_pred = model.predict(X_test)

# Đánh giá mô hình
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

print(f"Mean Squared Error: {mse:.2f}")
print(f"Root Mean Squared Error: {rmse:.2f}")
print(f"R² Score: {r2:.2f}")

# Hiển thị tầm quan trọng của các tính năng
importance = pd.DataFrame({'Feature': features, 'Importance': model.coef_})
importance = importance.sort_values('Importance', ascending=False)
print("\nTầm quan trọng của các tính năng:")
print(importance)

from sklearn.ensemble import RandomForestRegressor

# Khởi tạo mô hình
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)

# Huấn luyện mô hình
rf_model.fit(X_train, y_train)

# Dự đoán trên tập kiểm tra
rf_y_pred = rf_model.predict(X_test)

# Đánh giá mô hình
rf_mse = mean_squared_error(y_test, rf_y_pred)
rf_rmse = np.sqrt(rf_mse)
rf_r2 = r2_score(y_test, rf_y_pred)

print(f"Random Forest - MSE: {rf_mse:.2f}")
print(f"Random Forest - RMSE: {rf_rmse:.2f}")
print(f"Random Forest - R²: {rf_r2:.2f}")

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM
from tensorflow.keras.optimizers import Adam
from sklearn.preprocessing import MinMaxScaler

# Tái định dạng dữ liệu cho LSTM
def create_sequences(X, y, time_steps=10):
    Xs, ys = [], []
    for i in range(len(X) - time_steps):
        Xs.append(X[i:(i + time_steps)])
        ys.append(y[i + time_steps])
    return np.array(Xs), np.array(ys)

# Chuẩn hóa tất cả dữ liệu
scaler_X = MinMaxScaler()
scaler_y = MinMaxScaler()

X_scaled = scaler_X.fit_transform(data[features])
y_scaled = scaler_y.fit_transform(data[['Close']])

# Tạo chuỗi thời gian
time_steps = 10
X_seq, y_seq = create_sequences(X_scaled, y_scaled, time_steps)

# Chia tập dữ liệu
train_size = int(len(X_seq) * 0.8)
X_train_seq = X_seq[:train_size]
y_train_seq = y_seq[:train_size]
X_test_seq = X_seq[train_size:]
y_test_seq = y_seq[train_size:]

# Xây dựng mô hình LSTM
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train_seq.shape[1], X_train_seq.shape[2])))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(units=50))
model.add(Dropout(0.2))
model.add(Dense(units=1))

# Biên dịch mô hình
model.compile(optimizer=Adam(learning_rate=0.001), loss='mean_squared_error')

# Huấn luyện mô hình
history = model.fit(
    X_train_seq, y_train_seq,
    epochs=100,
    batch_size=32,
    validation_split=0.1,
    verbose=1
)

# Dự đoán
y_pred_seq = model.predict(X_test_seq)

# Chuyển đổi về giá trị gốc
y_test_inv = scaler_y.inverse_transform(y_test_seq)
y_pred_inv = scaler_y.inverse_transform(y_pred_seq)

# Đánh giá mô hình
lstm_mse = mean_squared_error(y_test_inv, y_pred_inv)
lstm_rmse = np.sqrt(lstm_mse)

print(f"LSTM - MSE: {lstm_mse:.2f}")
print(f"LSTM - RMSE: {lstm_rmse:.2f}")

def predict_future_prices(model, data, features, scaler, days=30):
    # Lấy dữ liệu cuối cùng
    last_data = data[features].iloc[-time_steps:].values
    last_data_scaled = scaler_X.transform(last_data)
    
    # Tạo danh sách để lưu trữ dự đoán
    future_predictions = []
    
    # Dự đoán cho 'days' ngày tiếp theo
    current_batch = last_data_scaled.reshape(1, time_steps, len(features))
    
    for _ in range(days):
        # Dự đoán giá tiếp theo
        future_price = model.predict(current_batch)[0]
        future_predictions.append(future_price)
        
        # Tạo dữ liệu mới cho dự đoán tiếp theo
        # (Dùng một cách đơn giản để minh họa - trong thực tế cần phức tạp hơn)
        new_data_point = current_batch[0][-1:].copy()
        new_data_point[0][0] = future_price[0]  # Thay đổi giá đóng cửa
        
        # Cập nhật batch hiện tại
        current_batch = np.append(current_batch[:,1:,:], [new_data_point], axis=1)
    
    # Chuyển đổi về giá trị gốc
    future_predictions = scaler_y.inverse_transform(np.array(future_predictions))
    
    return future_predictions

# Dự đoán giá cho 30 ngày tiếp theo
future_prices = predict_future_prices(model, data, features, scaler_X, days=30)

# Hiển thị kết quả
last_date = data.index[-1]
future_dates = pd.date_range(start=last_date + timedelta(days=1), periods=30)

future_df = pd.DataFrame({
    'Date': future_dates,
    'Predicted_Close': future_prices.flatten()
})

print(future_df)

plt.figure(figsize=(14, 7))

# Vẽ giá đóng cửa lịch sử
plt.plot(data.index[-100:], data['Close'][-100:], label='Giá lịch sử', color='blue')

# Vẽ giá dự đoán
plt.plot(future_df['Date'], future_df['Predicted_Close'], label='Giá dự đoán', color='red', linestyle='--')

# Thêm vùng tin cậy (mô phỏng - trong thực tế cần tính toán thêm)
confidence = 0.1  # 10% độ không chắc chắn
upper_bound = future_df['Predicted_Close'] * (1 + confidence)
lower_bound = future_df['Predicted_Close'] * (1 - confidence)

plt.fill_between(future_df['Date'], lower_bound, upper_bound, color='red', alpha=0.2, label='Khoảng tin cậy 90%')

plt.title(f'Dự đoán giá cổ phiếu {ticker}')
plt.xlabel('Ngày')
plt.ylabel('Giá (USD)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('stock_prediction_result.png')
plt.show()

from sklearn.ensemble import VotingRegressor

# Kết hợp các mô hình đã huấn luyện
ensemble_model = VotingRegressor([
    ('linear', LinearRegression()),
    ('random_forest', RandomForestRegressor(n_estimators=100, random_state=42)),
    ('svr', SVR(kernel='rbf', C=100, gamma=0.1, epsilon=.1))
])

# Huấn luyện mô hình kết hợp
ensemble_model.fit(X_train, y_train)

# Dự đoán
ensemble_y_pred = ensemble_model.predict(X_test)

# Đánh giá
ensemble_mse = mean_squared_error(y_test, ensemble_y_pred)
ensemble_rmse = np.sqrt(ensemble_mse)
ensemble_r2 = r2_score(y_test, ensemble_y_pred)

print(f"Ensemble - MSE: {ensemble_mse:.2f}")
print(f"Ensemble - RMSE: {ensemble_rmse:.2f}")
print(f"Ensemble - R²: {ensemble_r2:.2f}")

class DataCollector:
    def __init__(self):
        self.data_sources = {}
    
    def fetch_historical_data(self, symbol, timeframe, start_date, end_date):
        """Thu thập dữ liệu lịch sử"""
        data = pd.DataFrame()
        
        for source in self.data_sources.values():
            try:
                source_data = source.get_historical_data(
                    symbol, timeframe, start_date, end_date
                )
                data = pd.concat([data, source_data])
            except Exception as e:
                self.log_error(f"Error fetching data from {source}: {e}")
        
        return data.drop_duplicates()
    
    def validate_data(self, data):
        """Kiểm tra tính hợp lệ của dữ liệu"""
        # Kiểm tra missing values
        missing = data.isnull().sum()
        
        # Kiểm tra outliers
        outliers = self.detect_outliers(data)
        
        # Kiểm tra tính liên tục của dữ liệu
        gaps = self.find_data_gaps(data)
        
        return {
            'missing': missing,
            'outliers': outliers,
            'gaps': gaps
        }

class DataProcessor:
    def __init__(self):
        self.processors = {}
    
    def clean_data(self, data):
        """Làm sạch dữ liệu"""
        # Xử lý missing values
        data = self.handle_missing_values(data)
        
        # Xử lý outliers
        data = self.handle_outliers(data)
        
        # Chuẩn hóa dữ liệu
        data = self.normalize_data(data)
        
        return data
    
    def engineer_features(self, data):
        """Tạo các đặc trưng mới"""
        features = pd.DataFrame()
        
        # Tính toán các chỉ báo kỹ thuật
        features['sma'] = self.calculate_sma(data)
        features['rsi'] = self.calculate_rsi(data)
        features['macd'] = self.calculate_macd(data)
        
        # Tạo các đặc trưng thống kê
        features['returns'] = self.calculate_returns(data)
        features['volatility'] = self.calculate_volatility(data)
        
        return features

class SignalGenerator:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def generate_signals(self, data):
        """Tạo tín hiệu giao dịch"""
        signals = pd.DataFrame(index=data.index)
        
        # Áp dụng chiến lược
        signals['position'] = self.strategy.apply(data)
        
        # Tạo tín hiệu mua/bán
        signals['signal'] = signals['position'].diff()
        
        return signals
    
    def validate_signals(self, signals):
        """Kiểm tra tính hợp lệ của tín hiệu"""
        # Kiểm tra tín hiệu trùng lặp
        duplicate_signals = self.find_duplicate_signals(signals)
        
        # Kiểm tra tín hiệu đối lập
        conflicting_signals = self.find_conflicting_signals(signals)
        
        return {
            'duplicates': duplicate_signals,
            'conflicts': conflicting_signals
        }

class TradeSimulator:
    def __init__(self, initial_capital):
        self.initial_capital = initial_capital
        self.positions = {}
        self.trades = []
    
    def execute_trades(self, signals, data):
        """Mô phỏng thực hiện giao dịch"""
        portfolio = pd.DataFrame(index=signals.index)
        portfolio['capital'] = self.initial_capital
        
        for timestamp, signal in signals.iterrows():
            if signal['signal'] != 0:
                # Thực hiện giao dịch
                trade = self.execute_trade(
                    timestamp,
                    signal['signal'],
                    data.loc[timestamp]
                )
                self.trades.append(trade)
            
            # Cập nhật vốn
            portfolio.loc[timestamp, 'capital'] = self.calculate_portfolio_value(
                timestamp, data
            )
        
        return portfolio

class PerformanceAnalyzer:
    def __init__(self):
        self.metrics = {}
    
    def calculate_returns(self, portfolio):
        """Tính toán các chỉ số lợi nhuận"""
        returns = pd.Series(index=portfolio.index)
        
        # Tổng lợi nhuận
        returns['total_return'] = (
            portfolio['capital'].iloc[-1] / portfolio['capital'].iloc[0] - 1
        )
        
        # Lợi nhuận hàng năm
        returns['annual_return'] = self.calculate_annual_return(portfolio)
        
        # Tỷ lệ Sharpe
        returns['sharpe_ratio'] = self.calculate_sharpe_ratio(portfolio)
        
        return returns
    
    def analyze_drawdowns(self, portfolio):
        """Phân tích drawdown"""
        # Tính toán drawdown
        drawdown = self.calculate_drawdown(portfolio)
        
        # Phân tích thống kê
        stats = {
            'max_drawdown': drawdown.min(),
            'avg_drawdown': drawdown.mean(),
            'drawdown_duration': self.calculate_drawdown_duration(drawdown)
        }
        
        return stats

class RiskAnalyzer:
    def __init__(self):
        self.risk_metrics = {}
    
    def calculate_risk_metrics(self, portfolio):
        """Tính toán các chỉ số rủi ro"""
        metrics = {}
        
        # Độ biến động
        metrics['volatility'] = self.calculate_volatility(portfolio)
        
        # Value at Risk
        metrics['var'] = self.calculate_var(portfolio)
        
        # Expected Shortfall
        metrics['expected_shortfall'] = self.calculate_expected_shortfall(portfolio)
        
        return metrics
    
    def analyze_risk_attribution(self, portfolio):
        """Phân tích nguồn gốc rủi ro"""
        # Phân tích rủi ro theo tài sản
        asset_risk = self.analyze_asset_risk(portfolio)
        
        # Phân tích rủi ro theo yếu tố
        factor_risk = self.analyze_factor_risk(portfolio)
        
        return {
            'asset_risk': asset_risk,
            'factor_risk': factor_risk
        }

class ParameterOptimizer:
    def __init__(self, strategy):
        self.strategy = strategy
        self.optimization_methods = {}
    
    def optimize_parameters(self, data, param_grid):
        """Tối ưu hóa tham số"""
        results = []
        
        for params in self.generate_param_combinations(param_grid):
            # Chạy backtest với bộ tham số
            performance = self.run_backtest(data, params)
            
            # Đánh giá hiệu suất
            score = self.evaluate_performance(performance)
            
            results.append({
                'params': params,
                'score': score,
                'performance': performance
            })
        
        return self.select_best_parameters(results)
    
    def validate_optimization(self, results):
        """Kiểm tra tính hợp lệ của kết quả tối ưu"""
        # Kiểm tra overfitting
        overfitting = self.check_overfitting(results)
        
        # Kiểm tra tính ổn định
        stability = self.check_parameter_stability(results)
        
        return {
            'overfitting': overfitting,
            'stability': stability
        }

class WalkForwardAnalyzer:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def perform_walk_forward_analysis(self, data, window_size):
        """Thực hiện phân tích walk-forward"""
        results = []
        
        for i in range(len(data) - window_size):
            # Chia dữ liệu
            train_data = data.iloc[i:i+window_size]
            test_data = data.iloc[i+window_size:i+window_size+1]
            
            # Tối ưu hóa trên tập train
            optimal_params = self.optimize_parameters(train_data)
            
            # Kiểm tra trên tập test
            performance = self.test_strategy(test_data, optimal_params)
            
            results.append({
                'train_period': train_data.index,
                'test_period': test_data.index,
                'params': optimal_params,
                'performance': performance
            })
        
        return self.analyze_walk_forward_results(results)

class MarketConnector:
    def __init__(self, exchange_config):
        self.exchange = self.initialize_exchange(exchange_config)
        self.data_feeds = {}
        self.order_router = None
    
    def initialize_exchange(self, config):
        """Khởi tạo kết nối với sàn giao dịch"""
        try:
            exchange = ccxt.create_market(
                config['exchange'],
                {
                    'apiKey': config['api_key'],
                    'secret': config['api_secret'],
                    'enableRateLimit': True
                }
            )
            return exchange
        except Exception as e:
            self.log_error(f"Failed to initialize exchange: {e}")
            return None
    
    def setup_data_feeds(self, symbols, timeframes):
        """Thiết lập các luồng dữ liệu"""
        for symbol in symbols:
            for timeframe in timeframes:
                feed = self.create_data_feed(symbol, timeframe)
                self.data_feeds[f"{symbol}_{timeframe}"] = feed

class OrderManager:
    def __init__(self, exchange):
        self.exchange = exchange
        self.active_orders = {}
        self.order_history = []
    
    def place_order(self, symbol, order_type, side, amount, price=None):
        """Đặt lệnh giao dịch"""
        try:
            order = self.exchange.create_order(
                symbol=symbol,
                type=order_type,
                side=side,
                amount=amount,
                price=price
            )
            
            self.active_orders[order['id']] = order
            self.order_history.append(order)
            
            return order
        except Exception as e:
            self.log_error(f"Failed to place order: {e}")
            return None
    
    def cancel_order(self, order_id):
        """Hủy lệnh giao dịch"""
        try:
            result = self.exchange.cancel_order(order_id)
            if order_id in self.active_orders:
                del self.active_orders[order_id]
            return result
        except Exception as e:
            self.log_error(f"Failed to cancel order: {e}")
            return None

class SignalProcessor:
    def __init__(self, strategy):
        self.strategy = strategy
        self.signal_queue = Queue()
        self.signal_history = []
    
    def process_market_data(self, data):
        """Xử lý dữ liệu thị trường và tạo tín hiệu"""
        try:
            # Áp dụng chiến lược
            signal = self.strategy.generate_signal(data)
            
            # Kiểm tra tính hợp lệ của tín hiệu
            if self.validate_signal(signal):
                self.signal_queue.put(signal)
                self.signal_history.append(signal)
            
            return signal
        except Exception as e:
            self.log_error(f"Error processing market data: {e}")
            return None
    
    def validate_signal(self, signal):
        """Kiểm tra tính hợp lệ của tín hiệu"""
        # Kiểm tra các điều kiện
        if not signal:
            return False
        
        if signal['type'] not in ['buy', 'sell']:
            return False
        
        if signal['amount'] <= 0:
            return False
        
        return True

class PositionManager:
    def __init__(self, exchange):
        self.exchange = exchange
        self.positions = {}
        self.position_history = []
    
    def update_positions(self):
        """Cập nhật thông tin vị thế"""
        try:
            positions = self.exchange.fetch_positions()
            for position in positions:
                symbol = position['symbol']
                self.positions[symbol] = position
            return positions
        except Exception as e:
            self.log_error(f"Error updating positions: {e}")
            return None
    
    def calculate_position_size(self, signal, account_balance):
        """Tính toán kích thước vị thế"""
        risk_per_trade = 0.02  # 2% rủi ro mỗi giao dịch
        max_position_size = account_balance * risk_per_trade
        
        return min(signal['amount'], max_position_size)

class PositionLimiter:
    def __init__(self, max_position_size, max_leverage):
        self.max_position_size = max_position_size
        self.max_leverage = max_leverage
    
    def check_position_limit(self, symbol, size, price):
        """Kiểm tra giới hạn vị thế"""
        position_value = size * price
        
        # Kiểm tra kích thước vị thế
        if position_value > self.max_position_size:
            return False
        
        # Kiểm tra đòn bẩy
        leverage = position_value / self.get_account_equity()
        if leverage > self.max_leverage:
            return False
        
        return True

class StopLossManager:
    def __init__(self, max_loss_percent):
        self.max_loss_percent = max_loss_percent
        self.stop_orders = {}
    
    def place_stop_loss(self, position, entry_price):
        """Đặt lệnh stop loss"""
        if position['side'] == 'long':
            stop_price = entry_price * (1 - self.max_loss_percent)
        else:
            stop_price = entry_price * (1 + self.max_loss_percent)
        
        stop_order = self.place_order(
            position['symbol'],
            'stop',
            'sell' if position['side'] == 'long' else 'buy',
            position['amount'],
            stop_price
        )
        
        self.stop_orders[position['id']] = stop_order

class PerformanceMonitor:
    def __init__(self):
        self.metrics = {}
        self.alerts = []
    
    def track_performance(self, portfolio):
        """Theo dõi hiệu suất giao dịch"""
        # Tính toán các chỉ số
        self.metrics['total_return'] = self.calculate_total_return(portfolio)
        self.metrics['sharpe_ratio'] = self.calculate_sharpe_ratio(portfolio)
        self.metrics['max_drawdown'] = self.calculate_max_drawdown(portfolio)
        
        # Kiểm tra các ngưỡng cảnh báo
        self.check_alert_thresholds()
    
    def check_alert_thresholds(self):
        """Kiểm tra các ngưỡng cảnh báo"""
        if self.metrics['max_drawdown'] > 0.1:  # 10% drawdown
            self.alerts.append({
                'type': 'drawdown',
                'value': self.metrics['max_drawdown'],
                'timestamp': datetime.now()
            })

class ErrorHandler:
    def __init__(self):
        self.error_log = []
        self.recovery_procedures = {}
    
    def handle_error(self, error, context):
        """Xử lý lỗi hệ thống"""
        error_record = {
            'error': str(error),
            'context': context,
            'timestamp': datetime.now()
        }
        
        self.error_log.append(error_record)
        
        # Thực hiện quy trình khôi phục
        if error.type in self.recovery_procedures:
            self.recovery_procedures[error.type](error, context)
        
        # Gửi cảnh báo
        self.send_error_alert(error_record)