import ccxt
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime

# Khởi tạo exchange
exchange = ccxt.binance({
    'enableRateLimit': True,  # Tự động xử lý rate limit
    'options': {
        'defaultType': 'spot'  # Sử dụng spot trading
    }
})

# Kiểm tra kết nối
print(f"Exchange: {exchange.name}")
print(f"Markets: {len(exchange.markets)}")

def fetch_ohlcv(symbol, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu OHLCV từ Binance
    
    Parameters:
    - symbol: Cặp giao dịch (ví dụ: 'BTC/USDT')
    - timeframe: Khung thời gian ('1m', '5m', '1h', '4h', '1d')
    - limit: Số lượng nến muốn lấy (tối đa 1000)
    """
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        return df
    except Exception as e:
        print(f"Error fetching data: {e}")
        return None

# Ví dụ sử dụng
btc_data = fetch_ohlcv('BTC/USDT', '1h', 1000)
print(btc_data.head())

def fetch_multiple_ohlcv(symbol, timeframe='1h', since=None, limit=1000):
    """
    Lấy nhiều hơn 1000 nến bằng cách sử dụng since parameter
    """
    all_ohlcv = []
    while True:
        try:
            ohlcv = exchange.fetch_ohlcv(symbol, timeframe, since=since, limit=limit)
            if len(ohlcv) == 0:
                break
            all_ohlcv.extend(ohlcv)
            since = ohlcv[-1][0] + 1
        except Exception as e:
            print(f"Error: {e}")
            break
    return pd.DataFrame(all_ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])

def process_ohlcv_data(df):
    """
    Xử lý dữ liệu OHLCV
    """
    # Chuyển đổi timestamp
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    
    # Tính toán các chỉ báo
    df['returns'] = df['close'].pct_change()
    df['volatility'] = df['returns'].rolling(window=20).std()
    
    # Tính toán SMA
    df['SMA20'] = df['close'].rolling(window=20).mean()
    df['SMA50'] = df['close'].rolling(window=50).mean()
    
    return df

# Xử lý dữ liệu
btc_data = process_ohlcv_data(btc_data)

def save_data(df, filename, format='csv'):
    """
    Lưu dữ liệu ra file
    """
    if format == 'csv':
        df.to_csv(f"{filename}.csv", index=False)
    elif format == 'excel':
        df.to_excel(f"{filename}.xlsx", index=False)
    elif format == 'html':
        df.to_html(f"{filename}.html", index=False)
    else:
        print("Unsupported format")

# Ví dụ lưu dữ liệu
save_data(btc_data, 'btc_data', 'csv')
save_data(btc_data, 'btc_data', 'excel')

def plot_candlestick(df, title='BTC/USDT Price'):
    """
    Vẽ biểu đồ nến với Plotly
    """
    fig = go.Figure(data=[go.Candlestick(
        x=df['timestamp'],
        open=df['open'],
        high=df['high'],
        low=df['low'],
        close=df['close']
    )])
    
    # Thêm SMA
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA20'],
        name='SMA20',
        line=dict(color='blue')
    ))
    
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA50'],
        name='SMA50',
        line=dict(color='red')
    ))
    
    # Cập nhật layout
    fig.update_layout(
        title=title,
        yaxis_title='Price (USDT)',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ
fig = plot_candlestick(btc_data)
fig.show()

def plot_volume(df, title='BTC/USDT Volume'):
    """
    Vẽ biểu đồ volume
    """
    fig = go.Figure(data=[go.Bar(
        x=df['timestamp'],
        y=df['volume'],
        name='Volume'
    )])
    
    fig.update_layout(
        title=title,
        yaxis_title='Volume',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ volume
volume_fig = plot_volume(btc_data)
volume_fig.show()

def get_current_price(symbol):
    """
    Lấy giá hiện tại của một cặp giao dịch
    """
    try:
        ticker = exchange.fetch_ticker(symbol)
        return {
            'symbol': symbol,
            'last': ticker['last'],
            'bid': ticker['bid'],
            'ask': ticker['ask'],
            'volume': ticker['baseVolume'],
            'timestamp': datetime.fromtimestamp(ticker['timestamp']/1000)
        }
    except Exception as e:
        print(f"Error fetching ticker: {e}")
        return None

# Ví dụ lấy giá BTC/USDT
btc_ticker = get_current_price('BTC/USDT')
print(btc_ticker)

def fetch_multiple_symbols(symbols, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu từ nhiều cặp giao dịch
    """
    data = {}
    for symbol in symbols:
        data[symbol] = fetch_ohlcv(symbol, timeframe, limit)
    return data

# Ví dụ lấy dữ liệu nhiều cặp
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT']
multi_data = fetch_multiple_symbols(symbols)

def calculate_correlation(data_dict):
    """
    Tính toán tương quan giữa các cặp giao dịch
    """
    # Tạo DataFrame với giá đóng cửa của các cặp
    closes = pd.DataFrame()
    for symbol, df in data_dict.items():
        closes[symbol] = df['close']
    
    # Tính toán ma trận tương quan
    correlation = closes.corr()
    return correlation

# Tính và hiển thị tương quan
correlation = calculate_correlation(multi_data)
print(correlation)

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)

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}")