Spot vs Futures Trading: So Sánh Phí và Hướng Dẫn Lựa Chọn (2025)

Lựa chọn giữa spot trading và futures trading không chỉ phụ thuộc vào chiến lược đầu tư mà còn ảnh hưởng đáng kể đến chi phí giao dịch. Bài viết này sẽ phân tích chi tiết cấu trúc phí của cả hai loại hình và đưa ra hướng dẫn lựa chọn phù hợp.

Tổng Quan Cấu Trúc Phí

So Sánh Phí Cơ Bản

class SpotVsFuturesAnalyzer:
    def __init__(self):
        # Cấu trúc phí các sàn lớn (2025)
        self.exchange_fees = {
            'Binance': {
                'spot': {
                    'maker': 0.001,  # 0.1%
                    'taker': 0.001,  # 0.1%
                    'bnb_discount': 0.25  # 25% giảm
                },
                'futures': {
                    'maker': 0.0002,  # 0.02%
                    'taker': 0.0004,  # 0.04%
                    'bnb_discount': 0.1,  # 10% giảm
                    'funding_rate_range': (-0.01, 0.01),  # -1% to +1% daily
                    'liquidation_fee': 0.005  # 0.5%
                }
            },
            'OKX': {
                'spot': {
                    'maker': 0.0008,  # 0.08%
                    'taker': 0.001,   # 0.1%
                    'okb_discount': 0.2  # 20% giảm
                },
                'futures': {
                    'maker': 0.0002,  # 0.02%
                    'taker': 0.0005,  # 0.05%
                    'okb_discount': 0.2,  # 20% giảm
                    'funding_rate_range': (-0.0075, 0.0075),
                    'liquidation_fee': 0.005
                }
            },
            'Bybit': {
                'spot': {
                    'maker': 0.001,   # 0.1%
                    'taker': 0.001,   # 0.1%
                    'bbt_discount': 0.2  # 20% giảm
                },
                'futures': {
                    'maker': 0.0002,  # 0.02%
                    'taker': 0.0006,  # 0.06%
                    'bbt_discount': 0.2,  # 20% giảm
                    'funding_rate_range': (-0.0075, 0.0075),
                    'liquidation_fee': 0.0025  # 0.25%
                }
            }
        }
    
    def calculate_spot_trading_cost(self, exchange, trade_amount, order_type='taker', 
                                  use_discount=True):
        """Tính chi phí spot trading"""
        
        fees = self.exchange_fees[exchange]['spot']
        base_rate = fees[order_type]
        
        if use_discount:
            discount_key = [k for k in fees.keys() if 'discount' in k][0]
            discount = fees[discount_key]
            final_rate = base_rate * (1 - discount)
        else:
            final_rate = base_rate
        
        trading_fee = trade_amount * final_rate
        
        return {
            'exchange': exchange,
            'market_type': 'spot',
            'trade_amount': trade_amount,
            'base_rate': base_rate,
            'final_rate': final_rate,
            'trading_fee': trading_fee,
            'total_cost': trading_fee,
            'additional_costs': {},
            'use_discount': use_discount
        }
    
    def calculate_futures_trading_cost(self, exchange, trade_amount, leverage=1, 
                                     holding_days=1, order_type='taker', 
                                     use_discount=True, avg_funding_rate=0.0001):
        """Tính chi phí futures trading"""
        
        fees = self.exchange_fees[exchange]['futures']
        base_rate = fees[order_type]
        
        if use_discount:
            discount_key = [k for k in fees.keys() if 'discount' in k][0]
            discount = fees[discount_key]
            final_rate = base_rate * (1 - discount)
        else:
            final_rate = base_rate
        
        # Chi phí giao dịch cơ bản
        trading_fee = trade_amount * final_rate
        
        # Funding fee (8 giờ một lần = 3 lần/ngày)
        position_size = trade_amount * leverage
        funding_fee_per_session = position_size * avg_funding_rate
        total_funding_fee = funding_fee_per_session * 3 * holding_days
        
        # Liquidation risk cost (ước tính)
        liquidation_risk_cost = self._estimate_liquidation_cost(
            position_size, leverage, fees['liquidation_fee']
        )
        
        total_cost = trading_fee + abs(total_funding_fee) + liquidation_risk_cost
        
        return {
            'exchange': exchange,
            'market_type': 'futures',
            'trade_amount': trade_amount,
            'leverage': leverage,
            'holding_days': holding_days,
            'base_rate': base_rate,
            'final_rate': final_rate,
            'trading_fee': trading_fee,
            'funding_fee': total_funding_fee,
            'liquidation_risk_cost': liquidation_risk_cost,
            'total_cost': total_cost,
            'additional_costs': {
                'funding_fee': total_funding_fee,
                'liquidation_risk': liquidation_risk_cost
            },
            'use_discount': use_discount
        }
    
    def _estimate_liquidation_cost(self, position_size, leverage, liquidation_fee_rate):
        """Ước tính chi phí liquidation risk"""
        
        # Xác suất liquidation dựa trên leverage (simplified model)
        liquidation_probability = {
            1: 0.001,   # 0.1% cho no leverage
            2: 0.005,   # 0.5%
            5: 0.02,    # 2%
            10: 0.05,   # 5%
            20: 0.1,    # 10%
            50: 0.2,    # 20%
            100: 0.35   # 35%
        }
        
        # Lấy xác suất gần nhất
        prob = liquidation_probability.get(leverage, 0.1)
        
        # Chi phí liquidation = xác suất × position size × liquidation fee
        liquidation_cost = prob * position_size * liquidation_fee_rate
        
        return liquidation_cost
    
    def compare_spot_vs_futures(self, exchange, trade_amount, holding_days=1, 
                               leverage=1, scenarios=None):
        """So sánh chi phí spot vs futures"""
        
        if scenarios is None:
            scenarios = [
                {'name': 'Taker + No Discount', 'order_type': 'taker', 'use_discount': False},
                {'name': 'Taker + Discount', 'order_type': 'taker', 'use_discount': True},
                {'name': 'Maker + Discount', 'order_type': 'maker', 'use_discount': True}
            ]
        
        results = []
        
        for scenario in scenarios:
            spot_cost = self.calculate_spot_trading_cost(
                exchange, trade_amount, scenario['order_type'], scenario['use_discount']
            )
            
            futures_cost = self.calculate_futures_trading_cost(
                exchange, trade_amount, leverage, holding_days, 
                scenario['order_type'], scenario['use_discount']
            )
            
            # Tính savings
            cost_difference = spot_cost['total_cost'] - futures_cost['total_cost']
            savings_percentage = (cost_difference / spot_cost['total_cost']) * 100
            
            results.append({
                'scenario': scenario['name'],
                'spot': spot_cost,
                'futures': futures_cost,
                'cost_difference': cost_difference,
                'savings_percentage': savings_percentage,
                'cheaper_option': 'Futures' if cost_difference > 0 else 'Spot'
            })
        
        return results

# Ví dụ sử dụng
analyzer = SpotVsFuturesAnalyzer()

# So sánh cho giao dịch $10,000 trên Binance
trade_amount = 10000
exchange = 'Binance'

print(f"=== SO SÁNH SPOT VS FUTURES - {exchange.upper()} ===")
print(f"Trade amount: ${trade_amount:,}")

# Test với các leverage khác nhau
leverages = [1, 5, 10, 20]
holding_periods = [1, 7, 30]  # days

for leverage in leverages:
    print(f"\n--- LEVERAGE {leverage}x ---")
    
    for days in holding_periods:
        comparison = analyzer.compare_spot_vs_futures(
            exchange, trade_amount, days, leverage
        )
        
        print(f"\nHolding period: {days} day(s)")
        
        for result in comparison:
            scenario = result['scenario']
            spot = result['spot']
            futures = result['futures']
            
            print(f"  {scenario}:")
            print(f"    Spot: ${spot['total_cost']:.2f} ({spot['final_rate']*100:.3f}%)")
            print(f"    Futures: ${futures['total_cost']:.2f} (Trading: ${futures['trading_fee']:.2f}, Funding: ${futures['funding_fee']:.2f})")
            print(f"    Cheaper: {result['cheaper_option']} (Save: {abs(result['savings_percentage']):.1f}%)")

Phân Tích Chi Tiết Từng Loại Phí

Spot Trading Fees

class SpotTradingAnalysis:
    def __init__(self):
        self.spot_characteristics = {
            'fee_structure': {
                'trading_fees': 'Maker/Taker fees only',
                'funding_fees': 'None',
                'liquidation_fees': 'None',
                'overnight_fees': 'None'
            },
            'advantages': [
                'Cấu trúc phí đơn giản và minh bạch',
                'Không có funding fees',
                'Không có liquidation risk',
                'Sở hữu thực tế crypto',
                'Không có thời hạn'
            ],
            'disadvantages': [
                'Phí giao dịch cao hơn futures',
                'Không có leverage',
                'Cần vốn lớn cho position lớn',
                'Không thể short trong bear market'
            ]
        }
    
    def calculate_spot_holding_cost(self, initial_amount, holding_days, 
                                  daily_trading_frequency=0):
        """Tính chi phí hold spot trong thời gian dài"""
        
        # Chi phí giao dịch ban đầu (mua)
        initial_trading_fee = initial_amount * 0.001  # 0.1% taker
        
        # Chi phí giao dịch trong quá trình hold (nếu có DCA hoặc rebalance)
        daily_trading_cost = initial_amount * 0.001 * daily_trading_frequency
        total_intermediate_trading_cost = daily_trading_cost * holding_days
        
        # Chi phí bán cuối kỳ
        final_trading_fee = initial_amount * 0.001  # 0.1% taker
        
        total_cost = initial_trading_fee + total_intermediate_trading_cost + final_trading_fee
        
        return {
            'initial_trading_fee': initial_trading_fee,
            'intermediate_trading_cost': total_intermediate_trading_cost,
            'final_trading_fee': final_trading_fee,
            'total_cost': total_cost,
            'daily_cost': total_cost / holding_days,
            'cost_percentage': (total_cost / initial_amount) * 100
        }
    
    def spot_tax_implications(self, country='general'):
        """Phân tích tác động thuế của spot trading"""
        
        tax_implications = {
            'general': {
                'capital_gains': 'Áp dụng khi bán với lời',
                'holding_period': 'Long-term vs short-term rates',
                'cost_basis': 'FIFO, LIFO, or specific identification',
                'deductible_expenses': 'Trading fees có thể khấu trừ'
            },
            'advantages': [
                'Có thể hold để qualify cho long-term capital gains',
                'Không có funding fees để track',
                'Đơn giản hơn trong việc tính toán thuế'
            ],
            'considerations': [
                'Mỗi lần trade tạo ra taxable event',
                'Cần track cost basis cho từng coin',
                'Staking rewards có thể bị đánh thuế'
            ]
        }
        
        return tax_implications

# Ví dụ phân tích spot trading
spot_analysis = SpotTradingAnalysis()

# Tính chi phí hold $50,000 BTC trong các khoảng thời gian khác nhau
amounts = [10000, 50000, 100000]
holding_periods = [30, 90, 365]  # days
trading_frequencies = [0, 0.1, 0.5]  # times per day

print("=== SPOT TRADING COST ANALYSIS ===")

for amount in amounts:
    print(f"\nInitial amount: ${amount:,}")
    
    for days in holding_periods:
        print(f"\n  Holding period: {days} days")
        
        for freq in trading_frequencies:
            cost = spot_analysis.calculate_spot_holding_cost(amount, days, freq)
            
            freq_desc = {0: 'Buy & Hold', 0.1: 'Weekly DCA', 0.5: 'Active Trading'}
            strategy = freq_desc.get(freq, f'{freq} trades/day')
            
            print(f"    {strategy}:")
            print(f"      Total cost: ${cost['total_cost']:.2f} ({cost['cost_percentage']:.3f}%)")
            print(f"      Daily cost: ${cost['daily_cost']:.2f}")

# Tax implications
print(f"\n=== SPOT TRADING TAX IMPLICATIONS ===")
tax_info = spot_analysis.spot_tax_implications()

print("Advantages:")
for advantage in tax_info['advantages']:
    print(f"  • {advantage}")

print("\nConsiderations:")
for consideration in tax_info['considerations']:
    print(f"  • {consideration}")

Futures Trading Fees

class FuturesTradingAnalysis:
    def __init__(self):
        self.futures_characteristics = {
            'fee_structure': {
                'trading_fees': 'Lower maker/taker fees',
                'funding_fees': 'Every 8 hours',
                'liquidation_fees': 'When position liquidated',
                'overnight_fees': 'Included in funding'
            },
            'advantages': [
                'Phí giao dịch thấp hơn spot',
                'Có thể sử dụng leverage',
                'Có thể short market',
                'Capital efficiency cao',
                'Hedging opportunities'
            ],
            'disadvantages': [
                'Funding fees có thể cao',
                'Liquidation risk',
                'Phức tạp hơn',
                'Không sở hữu thực tế crypto',
                'Có thời hạn (perpetual thì không)'
            ]
        }
    
    def analyze_funding_rate_impact(self, position_size, leverage, days, 
                                  funding_scenarios=None):
        """Phân tích tác động của funding rate"""
        
        if funding_scenarios is None:
            funding_scenarios = {
                'bull_market': 0.0003,    # 0.03% per 8h (positive funding)
                'bear_market': -0.0002,   # -0.02% per 8h (negative funding)
                'neutral': 0.0001,        # 0.01% per 8h
                'extreme_bull': 0.001,    # 0.1% per 8h
                'extreme_bear': -0.0008   # -0.08% per 8h
            }
        
        results = {}
        
        for scenario, funding_rate in funding_scenarios.items():
            # Funding fee = position size × funding rate × sessions
            sessions_per_day = 3  # Every 8 hours
            total_sessions = days * sessions_per_day
            
            funding_fee_per_session = position_size * funding_rate
            total_funding_fee = funding_fee_per_session * total_sessions
            
            # Tính percentage của initial investment
            initial_investment = position_size / leverage
            funding_percentage = (abs(total_funding_fee) / initial_investment) * 100
            
            results[scenario] = {
                'funding_rate_per_session': funding_rate,
                'funding_fee_per_session': funding_fee_per_session,
                'total_funding_fee': total_funding_fee,
                'funding_percentage': funding_percentage,
                'daily_funding_cost': total_funding_fee / days,
                'is_paying': total_funding_fee > 0,
                'is_receiving': total_funding_fee < 0
            }
        
        return results
    
    def calculate_liquidation_levels(self, entry_price, leverage, side='long'):
        """Tính mức liquidation"""
        
        # Simplified liquidation calculation
        maintenance_margin_rate = 0.005  # 0.5% for most exchanges
        
        if side == 'long':
            # Long liquidation = entry_price × (1 - 1/leverage + maintenance_margin)
            liquidation_price = entry_price * (1 - 1/leverage + maintenance_margin_rate)
            price_drop_to_liquidation = ((entry_price - liquidation_price) / entry_price) * 100
        else:  # short
            # Short liquidation = entry_price × (1 + 1/leverage + maintenance_margin)
            liquidation_price = entry_price * (1 + 1/leverage + maintenance_margin_rate)
            price_rise_to_liquidation = ((liquidation_price - entry_price) / entry_price) * 100
        
        return {
            'entry_price': entry_price,
            'liquidation_price': liquidation_price,
            'leverage': leverage,
            'side': side,
            'price_move_to_liquidation': price_drop_to_liquidation if side == 'long' else price_rise_to_liquidation,
            'safety_margin': abs(entry_price - liquidation_price),
            'risk_level': self._assess_liquidation_risk(leverage)
        }
    
    def _assess_liquidation_risk(self, leverage):
        """Đánh giá mức độ rủi ro liquidation"""
        if leverage <= 2:
            return 'Very Low'
        elif leverage <= 5:
            return 'Low'
        elif leverage <= 10:
            return 'Medium'
        elif leverage <= 20:
            return 'High'
        else:
            return 'Very High'
    
    def futures_tax_implications(self):
        """Phân tích tác động thuế của futures trading"""
        
        return {
            'complexity_factors': [
                'Funding fees cần được track',
                'Mark-to-market accounting có thể áp dụng',
                'Liquidation events tạo ra realized losses',
                'Perpetual contracts có thể có treatment khác'
            ],
            'advantages': [
                'Losses có thể offset gains hiệu quả hơn',
                'Không cần hold để qualify long-term gains',
                'Hedging có thể có tax benefits'
            ],
            'challenges': [
                'Phức tạp hơn trong việc tính toán',
                'Funding fees có thể không deductible',
                'Frequent trading tạo ra nhiều taxable events'
            ]
        }

# Ví dụ phân tích futures trading
futures_analysis = FuturesTradingAnalysis()

# Phân tích funding rate impact
position_sizes = [50000, 100000, 200000]  # USD
leverages = [5, 10, 20]
holding_days = [7, 30, 90]

print("=== FUTURES FUNDING RATE ANALYSIS ===")

for pos_size in position_sizes:
    print(f"\nPosition size: ${pos_size:,}")
    
    for leverage in leverages:
        initial_investment = pos_size / leverage
        print(f"\n  Leverage {leverage}x (Initial investment: ${initial_investment:,})")
        
        for days in holding_days:
            funding_analysis = futures_analysis.analyze_funding_rate_impact(
                pos_size, leverage, days
            )
            
            print(f"\n    {days} days holding:")
            
            for scenario, data in funding_analysis.items():
                status = "Paying" if data['is_paying'] else "Receiving"
                print(f"      {scenario.replace('_', ' ').title()}: {status} ${abs(data['total_funding_fee']):.2f} ({data['funding_percentage']:.2f}%)")

# Liquidation analysis
print(f"\n=== LIQUIDATION LEVEL ANALYSIS ===")
entry_price = 50000  # BTC price
leverages = [2, 5, 10, 20, 50, 100]

for leverage in leverages:
    long_liq = futures_analysis.calculate_liquidation_levels(entry_price, leverage, 'long')
    short_liq = futures_analysis.calculate_liquidation_levels(entry_price, leverage, 'short')
    
    print(f"\nLeverage {leverage}x:")
    print(f"  Long liquidation: ${long_liq['liquidation_price']:,.0f} ({long_liq['price_move_to_liquidation']:.1f}% drop)")
    print(f"  Short liquidation: ${short_liq['liquidation_price']:,.0f} ({short_liq['price_move_to_liquidation']:.1f}% rise)")
    print(f"  Risk level: {long_liq['risk_level']}")

Khi Nào Chọn Spot vs Futures

Decision Framework

class SpotVsFuturesDecision:
    def __init__(self):
        self.decision_factors = {
            'trading_style': {
                'day_trading': {'spot': 2, 'futures': 8},
                'swing_trading': {'spot': 5, 'futures': 7},
                'position_trading': {'spot': 8, 'futures': 4},
                'buy_and_hold': {'spot': 10, 'futures': 1}
            },
            'capital_size': {
                'small': {'spot': 6, 'futures': 8},    # <$10k
                'medium': {'spot': 7, 'futures': 7},   # $10k-$100k
                'large': {'spot': 8, 'futures': 6}     # >$100k
            },
            'risk_tolerance': {
                'conservative': {'spot': 9, 'futures': 3},
                'moderate': {'spot': 6, 'futures': 6},
                'aggressive': {'spot': 3, 'futures': 9}
            },
            'market_direction': {
                'bullish': {'spot': 8, 'futures': 7},
                'bearish': {'spot': 2, 'futures': 9},
                'neutral': {'spot': 7, 'futures': 5}
            },
            'holding_period': {
                'short_term': {'spot': 3, 'futures': 8},    # <1 month
                'medium_term': {'spot': 6, 'futures': 6},   # 1-6 months
                'long_term': {'spot': 9, 'futures': 3}      # >6 months
            }
        }
    
    def analyze_user_profile(self, profile):
        """
        Phân tích profile người dùng và đưa ra khuyến nghị
        
        profile = {
            'trading_style': 'day_trading/swing_trading/position_trading/buy_and_hold',
            'capital_size': 'small/medium/large',
            'risk_tolerance': 'conservative/moderate/aggressive',
            'market_direction': 'bullish/bearish/neutral',
            'holding_period': 'short_term/medium_term/long_term'
        }
        """
        
        spot_score = 0
        futures_score = 0
        factor_analysis = {}
        
        for factor, value in profile.items():
            if factor in self.decision_factors and value in self.decision_factors[factor]:
                scores = self.decision_factors[factor][value]
                spot_score += scores['spot']
                futures_score += scores['futures']
                
                factor_analysis[factor] = {
                    'value': value,
                    'spot_score': scores['spot'],
                    'futures_score': scores['futures'],
                    'preference': 'Spot' if scores['spot'] > scores['futures'] else 'Futures'
                }
        
        total_possible = len(profile) * 10
        spot_percentage = (spot_score / total_possible) * 100
        futures_percentage = (futures_score / total_possible) * 100
        
        # Quyết định cuối cùng
        if spot_score > futures_score + 5:
            recommendation = 'SPOT'
            confidence = min((spot_score - futures_score) / 20, 1.0)
        elif futures_score > spot_score + 5:
            recommendation = 'FUTURES'
            confidence = min((futures_score - spot_score) / 20, 1.0)
        else:
            recommendation = 'MIXED'
            confidence = 0.5
        
        return {
            'recommendation': recommendation,
            'confidence': confidence,
            'spot_score': spot_score,
            'futures_score': futures_score,
            'spot_percentage': spot_percentage,
            'futures_percentage': futures_percentage,
            'factor_analysis': factor_analysis,
            'reasoning': self._generate_reasoning(factor_analysis, recommendation)
        }
    
    def _generate_reasoning(self, factor_analysis, recommendation):
        """Tạo lý do cho khuyến nghị"""
        
        strong_factors = []
        for factor, data in factor_analysis.items():
            if abs(data['spot_score'] - data['futures_score']) >= 3:
                strong_factors.append(f"{factor}: {data['preference']} ({data['value']})")
        
        reasoning = f"Khuyến nghị {recommendation} dựa trên: " + ", ".join(strong_factors[:3])
        
        return reasoning
    
    def cost_benefit_analysis(self, trade_amount, holding_days, leverage=1):
        """Phân tích cost-benefit cho quyết định cụ thể"""
        
        # Sử dụng analyzer đã tạo trước đó
        analyzer = SpotVsFuturesAnalyzer()
        
        # So sánh chi phí
        comparison = analyzer.compare_spot_vs_futures(
            'Binance', trade_amount, holding_days, leverage
        )
        
        # Phân tích risk-reward
        risk_analysis = {
            'spot_risks': [
                'Opportunity cost nếu không sử dụng leverage',
                'Không thể profit trong bear market',
                'Cần capital lớn'
            ],
            'futures_risks': [
                'Liquidation risk',
                'Funding fees có thể cao',
                'Complexity cao hơn'
            ],
            'spot_benefits': [
                'Không có liquidation risk',
                'Sở hữu thực tế crypto',
                'Đơn giản và minh bạch'
            ],
            'futures_benefits': [
                'Capital efficiency cao',
                'Có thể short market',
                'Phí giao dịch thấp hơn'
            ]
        }
        
        return {
            'cost_comparison': comparison,
            'risk_analysis': risk_analysis,
            'break_even_analysis': self._calculate_break_even(comparison)
        }
    
    def _calculate_break_even(self, comparison):
        """Tính break-even point giữa spot và futures"""
        
        # Lấy kết quả từ scenario tốt nhất
        best_scenario = min(comparison, key=lambda x: x['futures']['total_cost'])
        
        spot_cost = best_scenario['spot']['total_cost']
        futures_trading_cost = best_scenario['futures']['trading_fee']
        daily_funding_cost = abs(best_scenario['futures']['funding_fee']) / best_scenario['futures']['holding_days']
        
        if daily_funding_cost > 0:
            break_even_days = (spot_cost - futures_trading_cost) / daily_funding_cost
        else:
            break_even_days = float('inf')  # Futures luôn rẻ hơn
        
        return {
            'break_even_days': break_even_days,
            'interpretation': f"Futures rẻ hơn nếu hold < {break_even_days:.0f} ngày" if break_even_days < 365 else "Futures luôn rẻ hơn"
        }

# Ví dụ sử dụng decision framework
decision_maker = SpotVsFuturesDecision()

# Test với các profile khác nhau
test_profiles = [
    {
        'name': 'Conservative Long-term Investor',
        'profile': {
            'trading_style': 'buy_and_hold',
            'capital_size': 'medium',
            'risk_tolerance': 'conservative',
            'market_direction': 'bullish',
            'holding_period': 'long_term'
        }
    },
    {
        'name': 'Active Day Trader',
        'profile': {
            'trading_style': 'day_trading',
            'capital_size': 'small',
            'risk_tolerance': 'aggressive',
            'market_direction': 'neutral',
            'holding_period': 'short_term'
        }
    },
    {
        'name': 'Bear Market Trader',
        'profile': {
            'trading_style': 'swing_trading',
            'capital_size': 'large',
            'risk_tolerance': 'moderate',
            'market_direction': 'bearish',
            'holding_period': 'medium_term'
        }
    }
]

print("=== SPOT VS FUTURES DECISION ANALYSIS ===")

for test in test_profiles:
    print(f"\n{test['name']}:")
    analysis = decision_maker.analyze_user_profile(test['profile'])
    
    print(f"  Recommendation: {analysis['recommendation']}")
    print(f"  Confidence: {analysis['confidence']*100:.0f}%")
    print(f"  Spot score: {analysis['spot_percentage']:.0f}%")
    print(f"  Futures score: {analysis['futures_percentage']:.0f}%")
    print(f"  Reasoning: {analysis['reasoning']}")
    
    # Cost-benefit analysis cho trade $25,000, hold 30 ngày
    cost_benefit = decision_maker.cost_benefit_analysis(25000, 30, 5)
    break_even = cost_benefit['break_even_analysis']
    print(f"  Break-even: {break_even['interpretation']}")

Tối Ưu Hóa Chi Phí

Chiến Lược Hybrid

class HybridTradingStrategy:
    def __init__(self):
        self.strategy_combinations = {
            'core_satellite': {
                'description': 'Core position bằng spot, satellite positions bằng futures',
                'allocation': {'spot': 0.7, 'futures': 0.3},
                'use_cases': ['Long-term bullish với short-term trading']
            },
            'hedged_spot': {
                'description': 'Spot position được hedge bằng futures shorts',
                'allocation': {'spot': 1.0, 'futures_hedge': 0.2},
                'use_cases': ['Giữ crypto nhưng hedge downside risk']
            },
            'leveraged_dca': {
                'description': 'DCA bằng spot, leverage opportunities bằng futures',
                'allocation': {'spot_dca': 0.8, 'futures_leverage': 0.2},
                'use_cases': ['Tích lũy dài hạn với tactical leverage']
            },
            'arbitrage_focused': {
                'description': 'Arbitrage giữa spot và futures prices',
                'allocation': {'spot': 0.5, 'futures': 0.5},
                'use_cases': ['Profit từ basis spread']
            }
        }
    
    def design_hybrid_strategy(self, total_capital, risk_tolerance, market_outlook):
        """Thiết kế chiến lược hybrid"""
        
        if risk_tolerance == 'conservative':
            if market_outlook == 'bullish':
                strategy = 'core_satellite'
                spot_allocation = 0.8
                futures_allocation = 0.2
            else:
                strategy = 'hedged_spot'
                spot_allocation = 1.0
                futures_allocation = 0.1  # Hedge only
        
        elif risk_tolerance == 'moderate':
            if market_outlook == 'bullish':
                strategy = 'leveraged_dca'
                spot_allocation = 0.7
                futures_allocation = 0.3
            elif market_outlook == 'bearish':
                strategy = 'hedged_spot'
                spot_allocation = 0.6
                futures_allocation = 0.4
            else:
                strategy = 'arbitrage_focused'
                spot_allocation = 0.5
                futures_allocation = 0.5
        
        else:  # aggressive
            strategy = 'leveraged_dca'
            spot_allocation = 0.4
            futures_allocation = 0.6
        
        spot_capital = total_capital * spot_allocation
        futures_capital = total_capital * futures_allocation
        
        return {
            'strategy_name': strategy,
            'description': self.strategy_combinations[strategy]['description'],
            'total_capital': total_capital,
            'spot_allocation': {
                'amount': spot_capital,
                'percentage': spot_allocation * 100
            },
            'futures_allocation': {
                'amount': futures_capital,
                'percentage': futures_allocation * 100
            },
            'implementation_steps': self._get_implementation_steps(strategy),
            'risk_management': self._get_risk_management_rules(strategy)
        }
    
    def _get_implementation_steps(self, strategy):
        """Lấy các bước thực hiện cho strategy"""
        
        steps = {
            'core_satellite': [
                '1. Đầu tư 70-80% vào spot BTC/ETH làm core',
                '2. Sử dụng 20-30% cho futures trading các altcoins',
                '3. Rebalance monthly giữa core và satellite',
                '4. Take profit từ satellite để tăng core position'
            ],
            'hedged_spot': [
                '1. Mua spot position với full capital',
                '2. Mở futures short 10-20% để hedge',
                '3. Điều chỉnh hedge ratio theo market volatility',
                '4. Close hedge khi market sentiment cải thiện'
            ],
            'leveraged_dca': [
                '1. DCA spot position với 70% capital',
                '2. Sử dụng 30% cho leveraged futures khi có cơ hội',
                '3. Take profit từ futures để fund thêm DCA',
                '4. Maintain tỷ lệ spot/futures theo plan'
            ],
            'arbitrage_focused': [
                '1. Monitor basis spread giữa spot và futures',
                '2. Long spot + short futures khi basis cao',
                '3. Short spot + long futures khi basis âm',
                '4. Close positions khi spread thu hẹp'
            ]
        }
        
        return steps.get(strategy, [])
    
    def _get_risk_management_rules(self, strategy):
        """Lấy quy tắc quản lý rủi ro"""
        
        rules = {
            'core_satellite': [
                'Core position không bao giờ leverage',
                'Satellite position max 5x leverage',
                'Stop loss 10% cho satellite positions',
                'Rebalance khi allocation lệch >10%'
            ],
            'hedged_spot': [
                'Hedge ratio không quá 50%',
                'Monitor funding costs của hedge position',
                'Adjust hedge khi correlation thay đổi',
                'Set alerts cho liquidation levels'
            ],
            'leveraged_dca': [
                'DCA amount cố định không phụ thuộc P&L',
                'Leverage position max 10x',
                'Take profit 50% khi gain >20%',
                'Stop loss 15% cho leverage positions'
            ],
            'arbitrage_focused': [
                'Position size không quá 25% capital mỗi trade',
                'Monitor correlation giữa spot và futures',
                'Set tight stop losses cho arbitrage positions',
                'Close positions trước expiry nếu có'
            ]
        }
        
        return rules.get(strategy, [])
    
    def calculate_hybrid_costs(self, strategy_config, holding_days=30):
        """Tính chi phí cho hybrid strategy"""
        
        spot_amount = strategy_config['spot_allocation']['amount']
        futures_amount = strategy_config['futures_allocation']['amount']
        
        # Sử dụng analyzer để tính chi phí
        analyzer = SpotVsFuturesAnalyzer()
        
        # Chi phí spot
        spot_cost = analyzer.calculate_spot_trading_cost('Binance', spot_amount, 'maker', True)
        
        # Chi phí futures (giả sử leverage 5x)
        futures_cost = analyzer.calculate_futures_trading_cost(
            'Binance', futures_amount, 5, holding_days, 'maker', True
        )
        
        total_cost = spot_cost['total_cost'] + futures_cost['total_cost']
        total_capital = strategy_config['total_capital']
        
        return {
            'strategy': strategy_config['strategy_name'],
            'spot_cost': spot_cost,
            'futures_cost': futures_cost,
            'total_cost': total_cost,
            'cost_percentage': (total_cost / total_capital) * 100,
            'cost_breakdown': {
                'spot_trading_fee': spot_cost['trading_fee'],
                'futures_trading_fee': futures_cost['trading_fee'],
                'futures_funding_fee': futures_cost['funding_fee'],
                'futures_liquidation_risk': futures_cost['liquidation_risk_cost']
            }
        }

# Ví dụ sử dụng hybrid strategy
hybrid_strategy = HybridTradingStrategy()

# Test với các profile khác nhau
test_scenarios = [
    {'capital': 50000, 'risk': 'conservative', 'outlook': 'bullish'},
    {'capital': 100000, 'risk': 'moderate', 'outlook': 'neutral'},
    {'capital': 25000, 'risk': 'aggressive', 'outlook': 'bearish'}
]

print("=== HYBRID TRADING STRATEGIES ===")

for scenario in test_scenarios:
    strategy_config = hybrid_strategy.design_hybrid_strategy(
        scenario['capital'], scenario['risk'], scenario['outlook']
    )
    
    print(f"\nCapital: ${scenario['capital']:,} | Risk: {scenario['risk']} | Outlook: {scenario['outlook']}")
    print(f"Strategy: {strategy_config['strategy_name']}")
    print(f"Description: {strategy_config['description']}")
    print(f"Allocation: {strategy_config['spot_allocation']['percentage']:.0f}% Spot, {strategy_config['futures_allocation']['percentage']:.0f}% Futures")
    
    # Tính chi phí
    cost_analysis = hybrid_strategy.calculate_hybrid_costs(strategy_config)
    print(f"Total cost: ${cost_analysis['total_cost']:.2f} ({cost_analysis['cost_percentage']:.3f}%)")
    
    print("Implementation steps:")
    for step in strategy_config['implementation_steps'][:2]:  # Show first 2 steps
        print(f"  {step}")

Kết Luận và Khuyến Nghị

def generate_final_recommendations():
    """Tạo khuyến nghị cuối cùng cho Spot vs Futures"""
    
    recommendations = {
        'choose_spot_when': [
            'Bạn là investor dài hạn (>6 tháng)',
            'Risk tolerance thấp',
            'Muốn sở hữu thực tế crypto',
            'Không có kinh nghiệm với leverage',
            'Market outlook bullish và stable',
            'Capital lớn và không cần leverage'
        ],
        
        'choose_futures_when': [
            'Bạn là active trader (<1 tháng holding)',
            'Muốn sử dụng leverage',
            'Cần short market trong bear trend',
            'Capital nhỏ nhưng muốn exposure lớn',
            'Có kinh nghiệm quản lý risk',
            'Muốn hedge existing positions'
        ],
        
        'hybrid_approach_when': [
            'Capital trung bình ($10k-$100k)',
            'Risk tolerance moderate',
            'Muốn cân bằng growth và safety',
            'Có thời gian monitor positions',
            'Market outlook uncertain',
            'Muốn diversify strategies'
        ],
        
        'cost_optimization_tips': [
            'Sử dụng maker orders khi có thể',
            'Leverage token discounts (BNB, OKB, etc.)',
            'Monitor funding rates cho futures',
            'Consider VIP levels cho volume lớn',
            'Use limit orders để avoid slippage',
            'Plan trades để minimize tax impact'
        ],
        
        'risk_management_essentials': [
            'Never risk more than 2% per trade',
            'Set stop losses cho tất cả positions',
            'Diversify across multiple assets',
            'Keep emergency fund riêng biệt',
            'Regular review và adjust strategy',
            'Stay updated với market conditions'
        ]
    }
    
    return recommendations

# In khuyến nghị cuối cùng
final_recs = generate_final_recommendations()

print("=== FINAL RECOMMENDATIONS: SPOT VS FUTURES ===")

for category, items in final_recs.items():
    print(f"\n{category.replace('_', ' ').title()}:")
    for item in items:
        print(f"  • {item}")

print(f"\n=== SUMMARY ===")
print("Spot trading phù hợp cho long-term investors với risk tolerance thấp.")
print("Futures trading phù hợp cho active traders muốn leverage và flexibility.")
print("Hybrid approach cung cấp balance tốt nhất cho hầu hết traders.")
print("Quan trọng nhất: Hiểu rõ risks và costs trước khi quyết định.")

Việc lựa chọn giữa spot và futures trading phụ thuộc vào nhiều yếu tố bao gồm mục tiêu đầu tư, risk tolerance, capital size và kinh nghiệm trading. Spot trading đơn giản và an toàn hơn nhưng có chi phí cao hơn và ít flexibility. Futures trading có chi phí thấp hơn và nhiều cơ hội hơn nhưng phức tạp và rủi ro cao hơn. Hybrid approach thường là lựa chọn tối ưu cho hầu hết traders.