# vumanchu_scalping_v4.1.py - (Mit WT1 in Logging & Analyse)
from config import BINGX_CONFIG
import requests
import time
import hmac
import hashlib
from datetime import datetime
import os
import pandas as pd
import numpy as np
from typing import Dict, List, Tuple, Optional
pd.set_option('future.no_silent_downcasting', True)

# -----------------------------------------------------------------------------
# MODUL 1: INDIKATOR-BERECHNUNGEN
# -----------------------------------------------------------------------------

class IndicatorCalculator:
    """Berechnet alle notwendigen Indikatoren für das DataFrame."""
    
    def __init__(self, wt_chlen=9, wt_avg=12, wt_malen=3, rsi_len=14, mfi_len=60, mfi_mult=150, vol_sma_len=20):
        self.wt_chlen = wt_chlen
        self.wt_avg = wt_avg
        self.wt_malen = wt_malen
        self.rsi_len = rsi_len
        self.mfi_len = mfi_len
        self.mfi_mult = mfi_mult
        self.vol_sma_len = vol_sma_len
        self.ema_len = 200 

    def add_all_indicators(self, df):
        """Fügt alle Indikatoren zum DataFrame hinzu."""
        df = self._add_emas(df) 
        df = self._add_vwap(df) 
        df = self._add_wavetrend(df)
        df = self._add_rsi(df)
        df = self._add_rsimfi(df)
        df = self._add_volume_ratio(df)
        
        df.bfill(inplace=True)  
        df.fillna(0, inplace=True)
        return df

    def _add_emas(self, df):
        """Berechnet die Standard EMAs 20, 50, 200."""
        df['ema20'] = df['close'].ewm(span=20, adjust=False).mean()
        df['ema50'] = df['close'].ewm(span=50, adjust=False).mean()
        df['ema200'] = df['close'].ewm(span=200, adjust=False).mean()
        return df

    def _add_vwap(self, df):
        """Berechnet den echten, täglich zurückgesetzten VWAP."""
        try:
            tp = (df['high'] + df['low'] + df['close']) / 3
            tpv = tp * df['quote_volume'] 
            
            day_group = df['datetime'].dt.date
            
            cum_vol = df.groupby(day_group)['quote_volume'].cumsum()
            cum_tpv = tpv.groupby(day_group).cumsum()
            
            cum_vol_safe = cum_vol.replace(0, np.nan) 
            
            df['vwap'] = cum_tpv / cum_vol_safe
            
            df['vwap'] = df['vwap'].ffill()
            df['vwap'] = df['vwap'].bfill()

        except Exception as e:
            print(f"❌ Fehler bei VWAP-Berechnung: {e}")
            df['vwap'] = 0.0 
            
        return df

    def _add_wavetrend(self, df):
        src = df['close']
        esa = src.ewm(span=self.wt_chlen, adjust=False).mean()
        de = abs(src - esa).ewm(span=self.wt_chlen, adjust=False).mean()
        
        de_safe = de.replace(0, 0.0001)
        ci = (src - esa) / (0.015 * de_safe)
        
        df['wt1'] = ci.ewm(span=self.wt_avg, adjust=False).mean()
        df['wt2'] = df['wt1'].rolling(window=self.wt_malen).mean()
        df['wt_hist'] = df['wt1'] - df['wt2'] 
        return df

    def _add_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.rsi_len).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.rsi_len).mean()
        
        rs = gain / loss.replace(0, 0.0001)
        df['rsi'] = 100 - (100 / (1 + rs))
        return df

    def _add_rsimfi(self, df):
        high_low_diff = (df['high'] - df['low']).replace(0, 0.0001)
        close_open_diff = df['close'] - df['open']
        
        rsimfi_val = (close_open_diff / high_low_diff) * self.mfi_mult
        df['mfi'] = rsimfi_val.rolling(window=self.mfi_len).mean()
        return df

    def _add_volume_ratio(self, df):
        vol_sma = df['quote_volume'].rolling(window=self.vol_sma_len).mean()
        df['volume_ratio'] = df['quote_volume'] / vol_sma.replace(0, 1)
        return df

# -----------------------------------------------------------------------------
# MODUL 2: SIGNAL-ENGINE (Optimiert für Scalping)
# -----------------------------------------------------------------------------

class SignalEngine:
    """Findet Fraktale, Divergenzen und Signale im DataFrame - optimiert für Scalping."""
    
    def __init__(self, ob_level=48, os_level=-48, os_level3=-65):  # Engere Levels für Scalping
        self.ob_level = ob_level
        self.os_level = os_level
        self.os_level3 = os_level3

    def add_all_signals(self, df):
        df = self._add_fractals(df, 'wt2')
        df = self._add_divergences(df)
        df = self._add_circles_and_golden(df)
        return df

    def _add_fractals(self, df, osc_col='wt2'):
        is_top = (df[osc_col].shift(2) > df[osc_col].shift(4)) & \
                 (df[osc_col].shift(2) > df[osc_col].shift(3)) & \
                 (df[osc_col].shift(2) > df[osc_col].shift(1)) & \
                 (df[osc_col].shift(2) > df[osc_col])
        
        is_bot = (df[osc_col].shift(2) < df[osc_col].shift(4)) & \
                 (df[osc_col].shift(2) < df[osc_col].shift(3)) & \
                 (df[osc_col].shift(2) < df[osc_col].shift(1)) & \
                 (df[osc_col].shift(2) < df[osc_col])

        top_series = is_top.shift(-2)
        bot_series = is_bot.shift(-2)
        
        df['is_fractal_top'] = top_series.fillna(False).astype(bool)
        df['is_fractal_bot'] = bot_series.fillna(False).astype(bool)
        
        return df

    def _add_divergences(self, df):
        df['bot_price'] = np.where(df['is_fractal_bot'], df['low'], np.nan)
        df['bot_osc'] = np.where(df['is_fractal_bot'], df['wt2'], np.nan)
        df['top_price'] = np.where(df['is_fractal_top'], df['high'], np.nan)
        df['top_osc'] = np.where(df['is_fractal_top'], df['wt2'], np.nan)

        prev_bot_price = df['bot_price'].shift().ffill()
        prev_bot_osc = df['bot_osc'].shift().ffill()
        prev_top_price = df['top_price'].shift().ffill()
        prev_top_osc = df['top_osc'].shift().ffill()

        df['div_bull'] = (df['is_fractal_bot']) & \
                         (df['low'] < prev_bot_price) & \
                         (df['wt2'] > prev_bot_osc) & \
                         (df['wt2'] <= self.os_level)

        df['div_bear'] = (df['is_fractal_top']) & \
                         (df['high'] > prev_top_price) & \
                         (df['wt2'] < prev_top_osc) & \
                         (df['wt2'] >= self.ob_level)

        return df

    def _add_circles_and_golden(self, df):
        cross_up = (df['wt1'] > df['wt2']) & (df['wt1'].shift(1) <= df['wt2'].shift(1))
        cross_down = (df['wt1'] < df['wt2']) & (df['wt1'].shift(1) >= df['wt2'].shift(1))
        
        # ENTSPANNTE BEDINGUNGEN FÜR SCALPING
        df['circle_green'] = cross_up & (df['wt2'] <= self.os_level + 5)  # +5 Toleranz
        df['circle_red'] = cross_down & (df['wt2'] >= self.ob_level - 5)  # -5 Toleranz
        
        df['bot_rsi'] = np.where(df['is_fractal_bot'], df['rsi'], np.nan)
        
        last_fractal_bot_val = df['bot_osc'].ffill() 
        last_fractal_bot_rsi = df['bot_rsi'].ffill()

        # ENTSPANNTE GOLDEN BUY BEDINGUNGEN FÜR SCALPING
        cond1 = last_fractal_bot_val <= self.os_level3 + 10  # +10 Toleranz
        cond2 = df['wt2'] > self.os_level3
        cond3 = (last_fractal_bot_val - df['wt2']) <= -3    # -3 statt -5
        cond4 = last_fractal_bot_rsi < 35                   # 35 statt 30
        cond5 = df['div_bull'] 

        df['golden_buy'] = cond1 & cond2 & cond3 & cond4 & cond5
        
        return df

# -----------------------------------------------------------------------------
# MODUL 3: HAUPT-ANWENDUNG (v4.1 - Mit WT1 in Logging)
# -----------------------------------------------------------------------------

class ScalpingVuManChuAnalysis:
    def __init__(self, api_key: str, secret: str):
        self.api_key = api_key
        self.secret = secret
        self.base_url = "https://open-api.bingx.com"
        
        # KÜRZERE TIMEFRAMES FÜR SCALPING
        self.timeframes = {
            '1m': '1m', '3m': '3m', '5m': '5m', '15m': '15m'
        }
        self.htf_filter = {'1h': '1h'}  # Schnellere Reaktion als 4h
        
        self.log_file = "vumanchu_scalping_v4.0_log.csv"
        
        self.calculator = IndicatorCalculator()
        self.signal_engine = SignalEngine()
        
        self.volume_threshold = 1.1  # Reduziert für häufigere Signale
        
        self.setup_logging_v4_1()
        
    def setup_logging_v4_1(self):
        """Initialisiert die Log-Datei (v4.1) - MIT WT1 in allen Timeframes"""
        if not os.path.exists(self.log_file):
            with open(self.log_file, 'w', encoding='utf-8') as f:
                # WT1 HINZUGEFÜGT für alle Timeframes
                f.write("Timestamp,Price,"
                        "1m_WT1,1m_WT2,1m_MFI,1m_WTHist,1m_VWAP,1m_VolRatio,1m_EMA20,1m_EMA50,1m_EMA200,"
                        "3m_WT1,3m_WT2,3m_MFI,3m_WTHist,3m_VWAP,3m_VolRatio,3m_EMA20,3m_EMA50,3m_EMA200," 
                        "5m_WT1,5m_WT2,5m_MFI,5m_WTHist,5m_VWAP,5m_VolRatio,5m_EMA20,5m_EMA50,5m_EMA200,"
                        "15m_WT1,15m_WT2,15m_MFI,15m_WTHist,15m_VWAP,15m_VolRatio,15m_EMA20,15m_EMA50,15m_EMA200,"
                        "1h_WT1,1h_WT2,1h_MFI,1h_WTHist,1h_VWAP,1h_VolRatio,1h_EMA20,1h_EMA50,1h_EMA200\n")
    
    def log_data_v4_1(self, data):
        """Schreibt Daten in Log-Datei (v4.1) - MIT WT1 in allen Timeframes"""
        try:
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            
            # WT1 HINZUGEFÜGT für alle Timeframes
            log_entry = (
                f"{timestamp},"
                f"{data['price']:.2f},"
                # 1m Timeframe MIT WT1
                f"{data['1m_wt1']:.2f},{data['1m_wt2']:.2f},{data['1m_mfi']:.2f},{data['1m_wt_hist']:.2f},{data['1m_vwap']:.2f},{data['1m_vol_ratio']:.2f},{data['1m_ema20']:.2f},{data['1m_ema50']:.2f},{data['1m_ema200']:.2f},"
                # 3m Timeframe MIT WT1
                f"{data['3m_wt1']:.2f},{data['3m_wt2']:.2f},{data['3m_mfi']:.2f},{data['3m_wt_hist']:.2f},{data['3m_vwap']:.2f},{data['3m_vol_ratio']:.2f},{data['3m_ema20']:.2f},{data['3m_ema50']:.2f},{data['3m_ema200']:.2f},"
                # 5m Timeframe MIT WT1
                f"{data['5m_wt1']:.2f},{data['5m_wt2']:.2f},{data['5m_mfi']:.2f},{data['5m_wt_hist']:.2f},{data['5m_vwap']:.2f},{data['5m_vol_ratio']:.2f},{data['5m_ema20']:.2f},{data['5m_ema50']:.2f},{data['5m_ema200']:.2f},"
                # 15m Timeframe MIT WT1
                f"{data['15m_wt1']:.2f},{data['15m_wt2']:.2f},{data['15m_mfi']:.2f},{data['15m_wt_hist']:.2f},{data['15m_vwap']:.2f},{data['15m_vol_ratio']:.2f},{data['15m_ema20']:.2f},{data['15m_ema50']:.2f},{data['15m_ema200']:.2f},"
                # 1h Timeframe MIT WT1
                f"{data['1h_wt1']:.2f},{data['1h_wt2']:.2f},{data['1h_mfi']:.2f},{data['1h_wt_hist']:.2f},{data['1h_vwap']:.2f},{data['1h_vol_ratio']:.2f},{data['1h_ema20']:.2f},{data['1h_ema50']:.2f},{data['1h_ema200']:.2f}\n"
            )
            
            with open(self.log_file, 'a', encoding='utf-8') as f:
                f.write(log_entry)
            
            print(f"📝 Daten geloggt: {timestamp}")
            
        except Exception as e:
            print(f"❌ Logging Fehler: {e}")
    
    def get_klines_data_fixed(self, symbol='BTC-USDT', interval='5m', limit=250):
        try:
            timestamp = int(time.time() * 1000)
            params = f'symbol={symbol}&interval={interval}&limit={limit}&timestamp={timestamp}'
            signature = hmac.new(self.secret.encode(), params.encode(), hashlib.sha256).hexdigest()
            
            url = f'{self.base_url}/openApi/spot/v1/market/kline?{params}&signature={signature}'
            headers = {'X-BX-APIKEY': self.api_key}
            
            response = requests.get(url, headers=headers, timeout=10)
            data = response.json()
            
            if data['code'] == 0 and data['data']:
                df = pd.DataFrame(data['data'], columns=[
                    'timestamp', 'open', 'high', 'low', 'close', 'volume',
                    'close_time', 'quote_volume'
                ])
                
                df = df.astype({
                    'timestamp': 'int64', 'open': 'float64', 'high': 'float64',
                    'low': 'float64', 'close': 'float64', 'volume': 'float64',
                    'quote_volume': 'float64'
                })
                df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
                return df.sort_values('datetime').reset_index(drop=True)
            else:
                return pd.DataFrame()
                
        except Exception as e:
            print(f"❌ Kline Fehler ({interval}): {e}")
            return pd.DataFrame()
    
    def analyze_vumanchu_scalping(self, symbol='BTC-USDT'):
        """Führt die modulare Analyse durch (v4.1 - Scalping)"""
        analysis_data = {}
        
        all_timeframes = {**self.htf_filter, **self.timeframes}
        
        for tf_name, tf_value in all_timeframes.items():
            print(f"🔄 Analysiere {tf_name}...")
            df = self.get_klines_data_fixed(symbol=symbol, interval=tf_value, limit=250)
            
            if not df.empty and len(df) > self.calculator.ema_len:
                df = self.calculator.add_all_indicators(df)
                df = self.signal_engine.add_all_signals(df)
                
                latest_data = df.iloc[-1]
                
                analysis_data[tf_name] = {
                    'price': latest_data['close'],
                    'wt1': latest_data['wt1'], 'wt2': latest_data['wt2'],  # WT1 vorhanden!
                    'mfi': latest_data['mfi'], 
                    'wt_hist': latest_data['wt_hist'],
                    'vwap': latest_data['vwap'],
                    'rsi': latest_data['rsi'], 
                    'volume_ratio': latest_data['volume_ratio'],
                    'ema20': latest_data['ema20'],
                    'ema50': latest_data['ema50'],
                    'ema200': latest_data['ema200'],
                    'div_bull': latest_data['div_bull'], 'div_bear': latest_data['div_bear'],
                    'circle_green': latest_data['circle_green'], 'circle_red': latest_data['circle_red'],
                    'golden_buy': latest_data['golden_buy'],
                    'is_oversold': latest_data['wt2'] <= self.signal_engine.os_level,
                    'is_overbought': latest_data['wt2'] >= self.signal_engine.ob_level,
                    'is_ema_bullish': latest_data['close'] > latest_data['ema200'], 
                    'is_vwap_bullish': latest_data['close'] > latest_data['vwap']
                }
                print(f"✅ {tf_name} analysiert - Preis: ${latest_data['close']:.2f}, WT1: {latest_data['wt1']:.2f}, WT2: {latest_data['wt2']:.2f}")
            else:
                analysis_data[tf_name] = None
                print(f"❌ {tf_name} keine Daten (benötigt > 200 Kerzen)")
        
        return analysis_data
    
    def generate_scalping_signals(self, analysis):
        """Generiert Scalping-Signale (v4.1 mit optimierten Bedingungen)"""
        signals = []
        
        # GEWICHTUNG FÜR KÜRZERE TIMEFRAMES ERHÖHEN
        weights = {'1m': 3, '3m': 4, '5m': 3, '15m': 2, '1h': 0}
        
        score = 0
        
        htf_bias = "NEUTRAL"
        htf_data = analysis.get('1h')  # 1h statt 4h für schnellere Reaktion
        
        if htf_data:
            if htf_data['mfi'] > 0 and htf_data['is_ema_bullish']: 
                htf_bias = "BULLISH"
            elif htf_data['mfi'] < 0 and not htf_data['is_ema_bullish']:
                htf_bias = "BEARISH"
        
        for tf_name, data in analysis.items():
            if tf_name == '1h':  # Angepasst
                continue
            
            if data:
                tf_weight = weights.get(tf_name, 1)
                vol_confirmed = data['volume_ratio'] > self.volume_threshold
                local_vwap_bullish = data['is_vwap_bullish'] 

                # ENTSPANNTE SIGNAL-BEDINGUNGEN FÜR SCALPING
                if local_vwap_bullish:
                    if data['golden_buy']:  # Volume optional für Scalping
                        signals.append(f"🟢🟢 {tf_name} GOLDEN BUY (Scalping)")
                        score += 3 * tf_weight
                    
                    elif data['div_bull'] and vol_confirmed:
                        signals.append(f"🟢 {tf_name} Bullish Div (Vol Bestätigt)")
                        score += 2 * tf_weight

                    elif data['circle_green'] and data['mfi'] > -10:  # Entspannte MFI-Bedingung
                        signals.append(f"🟢 {tf_name} Green Circle (Scalping)")
                        score += 1 * tf_weight

                # BEARISH SIGNALE ENTSPANNEN
                if not local_vwap_bullish:
                    if data['div_bear']:  # Volume optional
                        signals.append(f"🔴 {tf_name} Bearish Div (Scalping)")
                        score -= 2 * tf_weight
                        
                    elif data['circle_red'] and data['mfi'] < 10:  # Entspannte MFI-Bedingung
                        signals.append(f"🔴 {tf_name} Red Circle (Scalping)")
                        score -= 1 * tf_weight
        
        # SCALPING-BIAS (REDUZIERTER EINFLUSS)
        if htf_bias == "BULLISH" and score > 0:
            signals.append(f"👍 1H-BIAS: Bullish Bonus ({htf_bias})")
            score += 1  # Reduziert von 2
        elif htf_bias == "BEARISH" and score > 0:
            signals.append(f"⚠️ 1H-BIAS: Bearish Malus ({htf_bias} Counter-Trend)")
            score -= 1  # Reduziert von 2
        elif htf_bias == "BEARISH" and score < 0:
            signals.append(f"👍 1H-BIAS: Bearish Bonus ({htf_bias})")
            score -= 1  # Reduziert von 2
        elif htf_bias == "BULLISH" and score < 0:
            signals.append(f"⚠️ 1H-BIAS: Bullish Malus ({htf_bias} Counter-Trend)")
            score += 1  # Reduziert von 2
            
        return signals, score, htf_bias
    
    def get_scalping_consensus(self, score):
        """Angepasste Schwellenwerte für Scalping"""
        # NIEDRIGERE SCHWELLENWERTE FÜR SCALPING
        if score >= 7: return "STRONG BULLISH"    # Reduziert von 9
        elif score >= 4: return "BULLISH"         # Reduziert von 6
        elif score <= -7: return "STRONG BEARISH" # Reduziert von -9
        elif score <= -4: return "BEARISH"        # Reduziert von -6
        else: return "NEUTRAL"

# -----------------------------------------------------------------------------
# MAIN (v4.1 - Mit WT1 in Logging & Anzeige)
# -----------------------------------------------------------------------------

def main():
    print("🚀 VuManChu Scalping Bot (v4.1 - Mit WT1 in Logging & Kurzfristige Trades)")
    print("=" * 70)
    
    analyzer = ScalpingVuManChuAnalysis(
        api_key=BINGX_CONFIG['API_KEY'],
        secret=BINGX_CONFIG['SECRET_KEY']
    )
    
    try:
        while True:
            os.system('cls' if os.name == 'nt' else 'clear')
            print("📊 VUMANCHU SCALPING ANALYSIS (1m-15m Timeframes) - MIT WT1")
            print("=" * 70)
            print(f"🕐 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            print()
            
            analysis = analyzer.analyze_vumanchu_scalping() 
            signals, score, htf_bias = analyzer.generate_scalping_signals(analysis)
            consensus = analyzer.get_scalping_consensus(score)
            
            if analysis.get('5m'):
                current_price = analysis['5m']['price']
                print(f"💰 BTC-USDT: ${current_price:,.2f}")
            
            print(f"\n🎯 KONSENS-SIGNAL: {consensus} (Score: {score:.1f})")
            
            if "STRONG BULLISH" in consensus: print("🟢🟢🟢 STARK BULLISH - KAUFEMPFEHLUNG")
            elif "BULLISH" in consensus: print("🟢🟢 BULLISH - Leichte Kaufempfehlung")
            elif "STRONG BEARISH" in consensus: print("🔴��🔴 STARK BEARISH - VERKAUFSEMPFEHLUNG")
            elif "BEARISH" in consensus: print("🔴🔴 BEARISH - Leichte Verkaufsempfehlung")
            else: print("🟡 NEUTRAL - Abwarten")
            
            print(f"\n📈 AKTIVE SIGNALE (Scalping-optimiert):")
            print("-" * 50)
            
            if not signals: print("• 🟡 Keine aktiven Signale")
            else:
                for signal in signals: print(f"• {signal}")
            
            print(f"\n📊 INDIKATOREN-ÜBERSICHT (MIT WT1 & WT2):")
            print("-" * 100)
            
            all_timeframes = {**analyzer.htf_filter, **analyzer.timeframes}
            for tf_name in all_timeframes.keys():
                if analysis.get(tf_name):
                    data = analysis[tf_name]
                    status = "NEUTRAL"
                    if data['is_oversold']: status = "OVERSOLD"
                    elif data['is_overbought']: status = "OVERBOUGHT"
                    
                    vwap_status = "BULL" if data['is_vwap_bullish'] else "BEAR"
                    
                    # WT1 HINZUGEFÜGT in der Anzeige
                    print(f"  {tf_name.upper():<4}: "
                          f"WT1={data['wt1']:6.1f} | "
                          f"WT2={data['wt2']:6.1f} | "
                          f"MFI={data['mfi']:6.1f} | "
                          f"Vol={data['volume_ratio']:4.2f}x | "
                          f"VWAP=${data['vwap']:.2f} [{vwap_status}] | "
                          f"[{status}]")
            
            # Logging (v4.1) - MIT WT1
            if all(tf in analysis and analysis[tf] for tf in all_timeframes.keys()):
                log_data = {
                    'price': analysis['5m']['price'], 
                    
                    # 1m Timeframe MIT WT1
                    '1m_wt1': analysis['1m']['wt1'], '1m_wt2': analysis['1m']['wt2'], '1m_mfi': analysis['1m']['mfi'], 
                    '1m_wt_hist': analysis['1m']['wt_hist'], '1m_vwap': analysis['1m']['vwap'], 
                    '1m_vol_ratio': analysis['1m']['volume_ratio'],
                    '1m_ema20': analysis['1m']['ema20'], '1m_ema50': analysis['1m']['ema50'], '1m_ema200': analysis['1m']['ema200'],
                    
                    # 3m Timeframe MIT WT1
                    '3m_wt1': analysis['3m']['wt1'], '3m_wt2': analysis['3m']['wt2'], '3m_mfi': analysis['3m']['mfi'], 
                    '3m_wt_hist': analysis['3m']['wt_hist'], '3m_vwap': analysis['3m']['vwap'], 
                    '3m_vol_ratio': analysis['3m']['volume_ratio'],
                    '3m_ema20': analysis['3m']['ema20'], '3m_ema50': analysis['3m']['ema50'], '3m_ema200': analysis['3m']['ema200'],
                    
                    # 5m Timeframe MIT WT1
                    '5m_wt1': analysis['5m']['wt1'], '5m_wt2': analysis['5m']['wt2'], '5m_mfi': analysis['5m']['mfi'], 
                    '5m_wt_hist': analysis['5m']['wt_hist'], '5m_vwap': analysis['5m']['vwap'], 
                    '5m_vol_ratio': analysis['5m']['volume_ratio'],
                    '5m_ema20': analysis['5m']['ema20'], '5m_ema50': analysis['5m']['ema50'], '5m_ema200': analysis['5m']['ema200'],
                    
                    # 15m Timeframe MIT WT1
                    '15m_wt1': analysis['15m']['wt1'], '15m_wt2': analysis['15m']['wt2'], '15m_mfi': analysis['15m']['mfi'], 
                    '15m_wt_hist': analysis['15m']['wt_hist'], '15m_vwap': analysis['15m']['vwap'], 
                    '15m_vol_ratio': analysis['15m']['volume_ratio'],
                    '15m_ema20': analysis['15m']['ema20'], '15m_ema50': analysis['15m']['ema50'], '15m_ema200': analysis['15m']['ema200'],
                    
                    # 1h Timeframe MIT WT1
                    '1h_wt1': analysis['1h']['wt1'], '1h_wt2': analysis['1h']['wt2'], '1h_mfi': analysis['1h']['mfi'],
                    '1h_wt_hist': analysis['1h']['wt_hist'], '1h_vwap': analysis['1h']['vwap'], 
                    '1h_vol_ratio': analysis['1h']['volume_ratio'],
                    '1h_ema20': analysis['1h']['ema20'], '1h_ema50': analysis['1h']['ema50'], '1h_ema200': analysis['1h']['ema200']
                }
                
                analyzer.log_data_v4_1(log_data)
            
            print(f"\n📝 LOGGING: Daten werden in '{analyzer.log_file}' gespeichert (MIT WT1)")
            print(f"🔄 Nächste Aktualisierung in 30s...")
            print("Drücke Ctrl+C zum Beenden")
            time.sleep(30)  # 30 Sekunden statt 60
            
    except KeyboardInterrupt:
        print("\n👋 VuManChu Scalping Bot gestoppt")
    except Exception as e:
        print(f"\n❌ EIN KRITISCHER FEHLER IST AUFGETRETEN: {e}")
        print("Stelle sicher, dass deine 'config.py' Datei existiert und korrekte Keys enthält.")


if __name__ == "__main__":
    main()