import pandas as pd
import numpy as np

class MovingAverage:
    def __init__(self, period=20, ma_type='SMA'):
        self.period = period
        self.ma_type = ma_type
    
    def calculate(self, df):
        if self.ma_type == 'SMA':
            return df['close'].rolling(window=self.period).mean()
        elif self.ma_type == 'EMA':
            return df['close'].ewm(span=self.period, adjust=False).mean()
        elif self.ma_type == 'WMA':
            weights = np.arange(1, self.period + 1)
            return df['close'].rolling(window=self.period).apply(
                lambda x: np.sum(weights * x) / weights.sum(), raw=True
            )

class MACD:
    def __init__(self, fast_period=12, slow_period=26, signal_period=9):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.signal_period = signal_period
    
    def calculate(self, df):
        # Tính toán MACD
        exp1 = df['close'].ewm(span=self.fast_period, adjust=False).mean()
        exp2 = df['close'].ewm(span=self.slow_period, adjust=False).mean()
        macd = exp1 - exp2
        signal = macd.ewm(span=self.signal_period, adjust=False).mean()
        histogram = macd - signal
        
        return pd.DataFrame({
            'MACD': macd,
            'Signal': signal,
            'Histogram': histogram
        })

class RSI:
    def __init__(self, period=14):
        self.period = period
    
    def calculate(self, df):
        # Tính toán RSI
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))
        
        return rsi

class StochasticOscillator:
    def __init__(self, k_period=14, d_period=3):
        self.k_period = k_period
        self.d_period = d_period
    
    def calculate(self, df):
        # Tính toán Stochastic
        low_min = df['low'].rolling(window=self.k_period).min()
        high_max = df['high'].rolling(window=self.k_period).max()
        
        k = 100 * ((df['close'] - low_min) / (high_max - low_min))
        d = k.rolling(window=self.d_period).mean()
        
        return pd.DataFrame({
            'K': k,
            'D': d
        })

class BollingerBands:
    def __init__(self, period=20, std_dev=2):
        self.period = period
        self.std_dev = std_dev
    
    def calculate(self, df):
        # Tính toán Bollinger Bands
        middle_band = df['close'].rolling(window=self.period).mean()
        std = df['close'].rolling(window=self.period).std()
        
        upper_band = middle_band + (std * self.std_dev)
        lower_band = middle_band - (std * self.std_dev)
        
        return pd.DataFrame({
            'Middle': middle_band,
            'Upper': upper_band,
            'Lower': lower_band
        })

class ATR:
    def __init__(self, period=14):
        self.period = period
    
    def calculate(self, df):
        # Tính toán ATR
        high_low = df['high'] - df['low']
        high_close = np.abs(df['high'] - df['close'].shift())
        low_close = np.abs(df['low'] - df['close'].shift())
        
        ranges = pd.concat([high_low, high_close, low_close], axis=1)
        true_range = np.max(ranges, axis=1)
        
        atr = true_range.rolling(window=self.period).mean()
        
        return atr

class OBV:
    def calculate(self, df):
        # Tính toán OBV
        obv = pd.Series(0.0, index=df.index)
        
        for i in range(1, len(df)):
            if df['close'].iloc[i] > df['close'].iloc[i-1]:
                obv.iloc[i] = obv.iloc[i-1] + df['volume'].iloc[i]
            elif df['close'].iloc[i] < df['close'].iloc[i-1]:
                obv.iloc[i] = obv.iloc[i-1] - df['volume'].iloc[i]
            else:
                obv.iloc[i] = obv.iloc[i-1]
        
        return obv

class MoneyFlowIndex:
    def __init__(self, period=14):
        self.period = period
    
    def calculate(self, df):
        # Tính toán Money Flow Index
        typical_price = (df['high'] + df['low'] + df['close']) / 3
        money_flow = typical_price * df['volume']
        
        positive_flow = pd.Series(0.0, index=df.index)
        negative_flow = pd.Series(0.0, index=df.index)
        
        for i in range(1, len(df)):
            if typical_price.iloc[i] > typical_price.iloc[i-1]:
                positive_flow.iloc[i] = money_flow.iloc[i]
            else:
                negative_flow.iloc[i] = money_flow.iloc[i]
        
        positive_mf = positive_flow.rolling(window=self.period).sum()
        negative_mf = negative_flow.rolling(window=self.period).sum()
        
        mfi = 100 - (100 / (1 + positive_mf / negative_mf))
        
        return mfi

import pandas as pd
import numpy as np

# Đọc dữ liệu giá
df = pd.read_csv('price_data.csv', index_col='date', parse_dates=True)

# Tính toán các chỉ số kỹ thuật
def calculate_technical_indicators(df):
    # Moving Average
    df['SMA_20'] = df['close'].rolling(window=20).mean()
    df['EMA_20'] = df['close'].ewm(span=20).mean()
    
    # RSI
    delta = df['close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    rs = gain / loss
    df['RSI'] = 100 - (100 / (1 + rs))
    
    # MACD
    exp1 = df['close'].ewm(span=12, adjust=False).mean()
    exp2 = df['close'].ewm(span=26, adjust=False).mean()
    df['MACD'] = exp1 - exp2
    df['Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
    
    return df

import numpy as np
from scipy import stats
from scipy.optimize import minimize

# Tính toán các thống kê
def calculate_statistics(returns):
    mean_return = np.mean(returns)
    volatility = np.std(returns)
    sharpe_ratio = mean_return / volatility
    skewness = stats.skew(returns)
    kurtosis = stats.kurtosis(returns)
    
    return {
        'mean': mean_return,
        'volatility': volatility,
        'sharpe': sharpe_ratio,
        'skewness': skewness,
        'kurtosis': kurtosis
    }

# Tối ưu hóa danh mục đầu tư
def optimize_portfolio(returns, cov_matrix):
    n_assets = len(returns)
    
    def portfolio_stats(weights):
        portfolio_return = np.sum(returns * weights)
        portfolio_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        sharpe = portfolio_return / portfolio_vol
        return -sharpe
    
    constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
    bounds = tuple((0, 1) for _ in range(n_assets))
    
    result = minimize(
        portfolio_stats,
        x0=np.array([1/n_assets] * n_assets),
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )
    
    return result.x

import tensorflow as tf
from tensorflow.keras import layers, models

# Xây dựng mô hình dự đoán giá
def build_price_prediction_model(input_shape):
    model = models.Sequential([
        layers.LSTM(64, input_shape=input_shape, return_sequences=True),
        layers.Dropout(0.2),
        layers.LSTM(32),
        layers.Dropout(0.2),
        layers.Dense(16, activation='relu'),
        layers.Dense(1)
    ])
    
    model.compile(
        optimizer='adam',
        loss='mse',
        metrics=['mae']
    )
    
    return model

# Huấn luyện mô hình
def train_model(model, X_train, y_train, X_val, y_val):
    history = model.fit(
        X_train, y_train,
        epochs=100,
        batch_size=32,
        validation_data=(X_val, y_val),
        callbacks=[
            tf.keras.callbacks.EarlyStopping(
                monitor='val_loss',
                patience=10
            )
        ]
    )
    return history

import torch
import torch.nn as nn

# Xây dựng mô hình phân loại tín hiệu
class SignalClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(SignalClassifier, self).__init__()
        self.lstm = nn.LSTM(
            input_dim,
            hidden_dim,
            num_layers=2,
            batch_first=True
        )
        self.fc = nn.Sequential(
            nn.Linear(hidden_dim, 32),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(32, output_dim)
        )
    
    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        return self.fc(lstm_out[:, -1, :])

# Huấn luyện mô hình
def train_classifier(model, train_loader, criterion, optimizer):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

import backtrader as bt

# Chiến lược giao dịch
class MovingAverageStrategy(bt.Strategy):
    params = (
        ('fast_period', 10),
        ('slow_period', 30),
    )
    
    def __init__(self):
        self.fast_ma = bt.indicators.SMA(
            self.data.close,
            period=self.params.fast_period
        )
        self.slow_ma = bt.indicators.SMA(
            self.data.close,
            period=self.params.slow_period
        )
        self.crossover = bt.indicators.CrossOver(
            self.fast_ma,
            self.slow_ma
        )
    
    def next(self):
        if not self.position:
            if self.crossover > 0:
                self.buy()
        else:
            if self.crossover < 0:
                self.sell()

# Chạy backtest
def run_backtest(data, strategy):
    cerebro = bt.Cerebro()
    cerebro.adddata(data)
    cerebro.addstrategy(strategy)
    cerebro.broker.setcash(100000.0)
    cerebro.broker.setcommission(commission=0.001)
    
    results = cerebro.run()
    return results

from zipline.api import order, record, symbol
from zipline.finance import commission, slippage

# Chiến lược giao dịch
def initialize(context):
    context.asset = symbol('AAPL')
    context.sma_period = 20
    
    # Thiết lập commission và slippage
    context.set_commission(commission.PerShare(cost=0.001, min_trade_cost=1.0))
    context.set_slippage(slippage.VolumeShareSlippage(volume_limit=0.025, price_impact=0.1))

def handle_data(context, data):
    # Tính toán SMA
    sma = data.history(context.asset, 'price', context.sma_period, '1d').mean()
    current_price = data.current(context.asset, 'price')
    
    # Tạo tín hiệu giao dịch
    if current_price > sma:
        order_target(context.asset, 100)
    else:
        order_target(context.asset, 0)
    
    # Ghi lại dữ liệu
    record(
        price=current_price,
        sma=sma
    )

import matplotlib.pyplot as plt
import seaborn as sns

# Vẽ biểu đồ giá và chỉ số
def plot_price_and_indicators(df):
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), gridspec_kw={'height_ratios': [3, 1]})
    
    # Biểu đồ giá và MA
    ax1.plot(df.index, df['close'], label='Price')
    ax1.plot(df.index, df['SMA_20'], label='SMA 20')
    ax1.plot(df.index, df['EMA_20'], label='EMA 20')
    ax1.set_title('Price and Moving Averages')
    ax1.legend()
    
    # Biểu đồ RSI
    ax2.plot(df.index, df['RSI'], label='RSI')
    ax2.axhline(y=70, color='r', linestyle='--')
    ax2.axhline(y=30, color='g', linestyle='--')
    ax2.set_title('RSI')
    ax2.legend()
    
    plt.tight_layout()
    return fig

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Tạo biểu đồ tương tác
def create_interactive_chart(df):
    fig = make_subplots(
        rows=3, cols=1,
        shared_xaxes=True,
        vertical_spacing=0.05,
        subplot_titles=('Price', 'Volume', 'RSI')
    )
    
    # Biểu đồ giá
    fig.add_trace(
        go.Candlestick(
            x=df.index,
            open=df['open'],
            high=df['high'],
            low=df['low'],
            close=df['close']
        ),
        row=1, col=1
    )
    
    # Biểu đồ khối lượng
    fig.add_trace(
        go.Bar(
            x=df.index,
            y=df['volume'],
            name='Volume'
        ),
        row=2, col=1
    )
    
    # Biểu đồ RSI
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df['RSI'],
            name='RSI'
        ),
        row=3, col=1
    )
    
    fig.update_layout(
        title='Interactive Trading Chart',
        xaxis_title='Date',
        height=800
    )
    
    return fig

class PairsTrading:
    def __init__(self, lookback_period=60):
        self.lookback_period = lookback_period
        self.pairs = {}
        self.positions = {}
    
    def find_cointegrated_pairs(self, price_data):
        """Tìm các cặp cổ phiếu có tính đồng tích hợp"""
        n = len(price_data.columns)
        pairs = []
        
        for i in range(n):
            for j in range(i+1, n):
                stock1 = price_data.columns[i]
                stock2 = price_data.columns[j]
                
                # Kiểm tra tính đồng tích hợp
                score, pvalue = self.cointegration_test(
                    price_data[stock1],
                    price_data[stock2]
                )
                
                if pvalue < 0.05:
                    pairs.append((stock1, stock2, score))
        
        return sorted(pairs, key=lambda x: x[2])
    
    def calculate_spread(self, pair):
        """Tính toán spread giữa hai cổ phiếu"""
        stock1, stock2 = pair
        spread = price_data[stock1] - self.beta * price_data[stock2]
        return spread
    
    def generate_signals(self, spread):
        """Tạo tín hiệu giao dịch dựa trên spread"""
        zscore = (spread - spread.mean()) / spread.std()
        
        signals = pd.Series(0, index=spread.index)
        signals[zscore > 2] = -1  # Bán cặp
        signals[zscore < -2] = 1  # Mua cặp
        
        return signals

class MeanReversion:
    def __init__(self, window=20, threshold=2):
        self.window = window
        self.threshold = threshold
    
    def calculate_zscore(self, prices):
        """Tính toán z-score của giá"""
        rolling_mean = prices.rolling(window=self.window).mean()
        rolling_std = prices.rolling(window=self.window).std()
        zscore = (prices - rolling_mean) / rolling_std
        return zscore
    
    def generate_signals(self, zscore):
        """Tạo tín hiệu giao dịch dựa trên z-score"""
        signals = pd.Series(0, index=zscore.index)
        signals[zscore > self.threshold] = -1  # Bán
        signals[zscore < -self.threshold] = 1  # Mua
        return signals

class DeepLearningTrader:
    def __init__(self, input_dim, hidden_layers, output_dim):
        self.model = self.build_model(input_dim, hidden_layers, output_dim)
        self.scaler = StandardScaler()
    
    def build_model(self, input_dim, hidden_layers, output_dim):
        """Xây dựng mô hình deep learning"""
        model = Sequential()
        
        # Thêm các lớp ẩn
        for units in hidden_layers:
            model.add(Dense(units, activation='relu'))
            model.add(Dropout(0.2))
        
        # Lớp đầu ra
        model.add(Dense(output_dim, activation='softmax'))
        
        model.compile(
            optimizer='adam',
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )
        
        return model
    
    def prepare_data(self, features, labels):
        """Chuẩn bị dữ liệu cho mô hình"""
        X = self.scaler.fit_transform(features)
        y = to_categorical(labels)
        return X, y
    
    def train(self, X, y, epochs=100, batch_size=32):
        """Huấn luyện mô hình"""
        history = self.model.fit(
            X, y,
            epochs=epochs,
            batch_size=batch_size,
            validation_split=0.2
        )
        return history

class ReinforcementTrader:
    def __init__(self, state_dim, action_dim):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.agent = self.build_agent()
    
    def build_agent(self):
        """Xây dựng agent học tăng cường"""
        model = Sequential([
            Dense(64, input_dim=self.state_dim, activation='relu'),
            Dense(32, activation='relu'),
            Dense(self.action_dim, activation='linear')
        ])
        
        agent = DQNAgent(
            model=model,
            memory=SequentialMemory(limit=50000, window_length=1),
            policy=EpsGreedyQPolicy(),
            nb_actions=self.action_dim
        )
        
        return agent
    
    def train(self, env, nb_steps=100000):
        """Huấn luyện agent"""
        self.agent.compile(Adam(lr=1e-3))
        self.agent.fit(env, nb_steps=nb_steps, visualize=False, verbose=1)

class MarketMaker:
    def __init__(self, spread_multiplier=1.5):
        self.spread_multiplier = spread_multiplier
        self.inventory = {}
        self.position_limits = {}
    
    def calculate_quotes(self, order_book):
        """Tính toán giá chào mua/bán"""
        mid_price = (order_book['bid'][0] + order_book['ask'][0]) / 2
        spread = order_book['ask'][0] - order_book['bid'][0]
        
        # Điều chỉnh spread dựa trên vị thế
        inventory_skew = self.calculate_inventory_skew()
        adjusted_spread = spread * self.spread_multiplier * (1 + abs(inventory_skew))
        
        bid_price = mid_price - adjusted_spread/2
        ask_price = mid_price + adjusted_spread/2
        
        return bid_price, ask_price
    
    def calculate_inventory_skew(self):
        """Tính toán độ lệch vị thế"""
        total_inventory = sum(self.inventory.values())
        max_position = max(self.position_limits.values())
        return total_inventory / max_position

class OrderFlowAnalyzer:
    def __init__(self, window=100):
        self.window = window
        self.order_flow = []
        self.indicators = {}
    
    def analyze_order_flow(self, orders):
        """Phân tích luồng lệnh"""
        self.order_flow.extend(orders)
        if len(self.order_flow) > self.window:
            self.order_flow = self.order_flow[-self.window:]
        
        self.calculate_indicators()
        return self.generate_signals()
    
    def calculate_indicators(self):
        """Tính toán các chỉ số"""
        # Tỷ lệ khối lượng mua/bán
        buy_volume = sum(o['volume'] for o in self.order_flow if o['side'] == 'buy')
        sell_volume = sum(o['volume'] for o in self.order_flow if o['side'] == 'sell')
        self.indicators['volume_ratio'] = buy_volume / sell_volume
        
        # Áp lực mua/bán
        self.indicators['buying_pressure'] = self.calculate_buying_pressure()

class SentimentAnalyzer:
    def __init__(self):
        self.nlp = spacy.load('en_core_web_sm')
        self.sentiment_model = self.load_sentiment_model()
    
    def analyze_text(self, text):
        """Phân tích tâm lý từ văn bản"""
        # Tiền xử lý
        doc = self.nlp(text)
        cleaned_text = self.preprocess_text(doc)
        
        # Phân tích tâm lý
        sentiment_score = self.sentiment_model.predict(cleaned_text)
        
        return {
            'score': sentiment_score,
            'magnitude': abs(sentiment_score),
            'direction': 'positive' if sentiment_score > 0 else 'negative'
        }
    
    def aggregate_sentiment(self, texts):
        """Tổng hợp tâm lý từ nhiều nguồn"""
        sentiments = [self.analyze_text(text) for text in texts]
        
        return {
            'average_score': np.mean([s['score'] for s in sentiments]),
            'confidence': np.std([s['score'] for s in sentiments]),
            'volume': len(sentiments)
        }

class SatelliteImageAnalyzer:
    def __init__(self):
        self.model = self.load_image_model()
    
    def analyze_image(self, image):
        """Phân tích hình ảnh vệ tinh"""
        # Tiền xử lý hình ảnh
        processed_image = self.preprocess_image(image)
        
        # Phân tích đối tượng
        objects = self.detect_objects(processed_image)
        
        # Tính toán các chỉ số
        metrics = self.calculate_metrics(objects)
        
        return metrics
    
    def calculate_metrics(self, objects):
        """Tính toán các chỉ số từ đối tượng phát hiện được"""
        return {
            'activity_level': self.calculate_activity(objects),
            'inventory_level': self.estimate_inventory(objects),
            'traffic_density': self.measure_traffic(objects)
        }

class DataCollector:
    def __init__(self, config):
        self.config = config
        self.data_sources = {}
        self.initialize_data_sources()
    
    def initialize_data_sources(self):
        """Khởi tạo các nguồn dữ liệu"""
        for source in self.config['data_sources']:
            if source['type'] == 'market_data':
                self.data_sources[source['name']] = MarketDataAPI(source)
            elif source['type'] == 'fundamental_data':
                self.data_sources[source['name']] = FundamentalDataAPI(source)
    
    def collect_data(self, symbols, data_types):
        """Thu thập dữ liệu từ các nguồn"""
        collected_data = {}
        for symbol in symbols:
            for data_type in data_types:
                source = self.get_data_source(data_type)
                data = source.fetch_data(symbol, data_type)
                collected_data[f"{symbol}_{data_type}"] = data
        return collected_data

class DataProcessor:
    def __init__(self):
        self.processors = {}
        self.initialize_processors()
    
    def initialize_processors(self):
        """Khởi tạo các bộ xử lý dữ liệu"""
        self.processors['market_data'] = MarketDataProcessor()
        self.processors['fundamental_data'] = FundamentalDataProcessor()
        self.processors['sentiment_data'] = SentimentDataProcessor()
    
    def process_data(self, raw_data, data_type):
        """Xử lý dữ liệu thô"""
        processor = self.processors[data_type]
        processed_data = processor.process(raw_data)
        return self.validate_data(processed_data)
    
    def validate_data(self, data):
        """Kiểm tra tính hợp lệ của dữ liệu"""
        if data.isnull().any():
            data = self.handle_missing_data(data)
        return data

class StrategyEngine:
    def __init__(self, strategies):
        self.strategies = strategies
        self.signal_generator = SignalGenerator()
        self.position_manager = PositionManager()
        self.risk_controller = RiskController()
    
    def generate_signals(self, market_data):
        """Tạo tín hiệu giao dịch"""
        signals = []
        for strategy in self.strategies:
            # Áp dụng chiến lược
            strategy_signals = strategy.apply(market_data)
            
            # Kiểm tra rủi ro
            valid_signals = self.risk_controller.validate_signals(strategy_signals)
            
            # Quản lý vị thế
            position_adjusted_signals = self.position_manager.adjust_signals(valid_signals)
            
            signals.extend(position_adjusted_signals)
        
        return self.aggregate_signals(signals)
    
    def aggregate_signals(self, signals):
        """Tổng hợp các tín hiệu"""
        aggregated = {}
        for signal in signals:
            key = f"{signal['symbol']}_{signal['timeframe']}"
            if key not in aggregated:
                aggregated[key] = []
            aggregated[key].append(signal)
        return self.resolve_conflicts(aggregated)

class PositionManager:
    def __init__(self, config):
        self.config = config
        self.positions = {}
        self.position_limits = config['position_limits']
    
    def adjust_signals(self, signals):
        """Điều chỉnh tín hiệu theo vị thế hiện tại"""
        adjusted_signals = []
        for signal in signals:
            current_position = self.get_position(signal['symbol'])
            
            # Kiểm tra giới hạn vị thế
            if not self.check_position_limits(signal, current_position):
                continue
            
            # Tính toán kích thước vị thế
            position_size = self.calculate_position_size(signal)
            
            # Tạo tín hiệu điều chỉnh
            adjusted_signal = self.create_adjusted_signal(signal, position_size)
            adjusted_signals.append(adjusted_signal)
        
        return adjusted_signals

class OrderRouter:
    def __init__(self, exchanges):
        self.exchanges = exchanges
        self.order_manager = OrderManager()
        self.execution_optimizer = ExecutionOptimizer()
    
    def route_order(self, order):
        """Định tuyến đơn hàng đến sàn giao dịch phù hợp"""
        # Tối ưu hóa thực thi
        optimized_order = self.execution_optimizer.optimize(order)
        
        # Chọn sàn giao dịch
        exchange = self.select_exchange(optimized_order)
        
        # Gửi đơn hàng
        execution_result = self.execute_order(optimized_order, exchange)
        
        # Cập nhật trạng thái
        self.order_manager.update_order_status(execution_result)
        
        return execution_result
    
    def select_exchange(self, order):
        """Chọn sàn giao dịch phù hợp"""
        exchange_scores = {}
        for exchange in self.exchanges:
            score = self.calculate_exchange_score(exchange, order)
            exchange_scores[exchange] = score
        return max(exchange_scores.items(), key=lambda x: x[1])[0]