# vumanchu_scalping_v4.1_ai_data.py - Clean Data Output for AI
from config import BINGX_CONFIG
import requests
import time
import hmac
import hashlib
from datetime import datetime
import os
import csv
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 = self._add_macd(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 (KeyError, AttributeError) 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):
        """BEIDE Indikatoren - traditioneller MFI + dein Custom Oscillator"""
        
        # 1. TRADITIONELLER MFI (NEU)
        typical_price = (df['high'] + df['low'] + df['close']) / 3
        money_flow = typical_price * df['quote_volume']
        
        price_change = typical_price.diff()
        positive_flow = np.where(price_change > 0, money_flow, 0)
        negative_flow = np.where(price_change < 0, money_flow, 0)
        
        positive_flow_sum = pd.Series(positive_flow).rolling(window=14, min_periods=1).sum()
        negative_flow_sum = pd.Series(negative_flow).rolling(window=14, min_periods=1).sum()
        
        money_ratio = positive_flow_sum / negative_flow_sum.replace(0, 1)
        df['mfi_real'] = 100 - (100 / (1 + money_ratio))
        
        # 2. DEIN CUSTOM OSCILLATOR (BESTEHEND - UNVERÄNDERT)
        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()  # Dein originaler Name bleibt!
        
        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

    def _add_macd(self, df, fast_len=12, slow_len=26, signal_len=9):
        """Berechnet den MACD-Indikator."""
        ema_fast = df['close'].ewm(span=fast_len, adjust=False).mean()
        ema_slow = df['close'].ewm(span=slow_len, adjust=False).mean()
        df['macd'] = ema_fast - ema_slow
        df['macd_signal'] = df['macd'].ewm(span=signal_len, adjust=False).mean()
        df['macd_hist'] = df['macd'] - df['macd_signal']
        return df

# -----------------------------------------------------------------------------
# MODUL 2: HAUPT-ANWENDUNG (v4.1 - Nur Datenausgabe)
# -----------------------------------------------------------------------------

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"
        
        # Timeframes für Daten-Sampling
        self.timeframes = {
            '1m': '1m', '3m': '3m', '5m': '5m', '15m': '15m', '1h': '1h'
        }
        
        # Dateien für Datenausgabe
        self.data_file = "vumanchu_ai_data.csv"
        self.raw_data_file = "vumanchu_raw_data.csv"
        
        self.calculator = IndicatorCalculator()
        
        self.setup_data_files()
        
    def setup_data_files(self):
        """Initialisiert die Daten-Dateien mit Headern."""
        # Haupt-Datendatei
        if not os.path.exists(self.data_file):
            with open(self.data_file, 'w', encoding='utf-8') as f:
                f.write("Timestamp,Symbol,Price,"
                        "1m_WT1,1m_WT2,1m_RSI,1m_MFI,1m_MFI_Real,1m_WTHist,1m_VWAP,1m_VolRatio,1m_EMA20,1m_EMA50,1m_EMA200,"
                        "3m_WT1,3m_WT2,3m_RSI,3m_MFI,3m_MFI_Real,3m_WTHist,3m_VWAP,3m_VolRatio,3m_EMA20,3m_EMA50,3m_EMA200," 
                        "5m_WT1,5m_WT2,5m_RSI,5m_MFI,5m_MFI_Real,5m_WTHist,5m_VWAP,5m_VolRatio,5m_EMA20,5m_EMA50,5m_EMA200,"
                        "15m_WT1,15m_WT2,15m_RSI,15m_MFI,15m_MFI_Real,15m_WTHist,15m_VWAP,15m_VolRatio,15m_EMA20,15m_EMA50,15m_EMA200,"
                        "1h_WT1,1h_WT2,1h_RSI,1h_MFI,1h_MFI_Real,1h_WTHist,1h_VWAP,1h_VolRatio,1h_EMA20,1h_EMA50,1h_EMA200," \
                        "1m_MACD,1m_MACD_Signal,1m_MACD_Hist," \
                        "3m_MACD,3m_MACD_Signal,3m_MACD_Hist," \
                        "5m_MACD,5m_MACD_Signal,5m_MACD_Hist," \
                        "15m_MACD,15m_MACD_Signal,15m_MACD_Hist," \
                        "1h_MACD,1h_MACD_Signal,1h_MACD_Hist\n")
        
        # Rohdatendatei für erweiterte Analyse
        if not os.path.exists(self.raw_data_file):
            with open(self.raw_data_file, 'w', encoding='utf-8') as f:
                f.write("Timestamp,Symbol,Timeframe,Open,High,Low,Close,Volume,QuoteVolume,"
                        "WT1,WT2,RSI,MFI,MFI_Real,WT_Hist,VWAP,VolumeRatio,EMA20,EMA50,EMA200,MACD,MACD_Signal,MACD_Hist\n")
    
    def log_ai_data(self, data):
        """Schreibt bereinigte Daten für AI in Hauptdatei."""
        try:
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            
            log_entry = [
                timestamp, 'BTC-USDT',
                f"{data['price']:.2f}",
                # 1m Timeframe
                f"{data['1m_wt1']:.2f}", f"{data['1m_wt2']:.2f}", f"{data['1m_rsi']:.2f}", f"{data['1m_mfi']:.2f}", f"{data['1m_mfi_real']:.2f}", f"{data['1m_wt_hist']:.2f}", f"{data['1m_vwap']:.2f}", f"{data['1m_vol_ratio']:.2f}", f"{data['1m_ema20']:.2f}", f"{data['1m_ema50']:.2f}", f"{data['1m_ema200']:.2f}",
                # 3m Timeframe
                f"{data['3m_wt1']:.2f}", f"{data['3m_wt2']:.2f}", f"{data['3m_rsi']:.2f}", f"{data['3m_mfi']:.2f}", f"{data['3m_mfi_real']:.2f}", f"{data['3m_wt_hist']:.2f}", f"{data['3m_vwap']:.2f}", f"{data['3m_vol_ratio']:.2f}", f"{data['3m_ema20']:.2f}", f"{data['3m_ema50']:.2f}", f"{data['3m_ema200']:.2f}",
                # 5m Timeframe
                f"{data['5m_wt1']:.2f}", f"{data['5m_wt2']:.2f}", f"{data['5m_rsi']:.2f}", f"{data['5m_mfi']:.2f}", f"{data['5m_mfi_real']:.2f}", f"{data['5m_wt_hist']:.2f}", f"{data['5m_vwap']:.2f}", f"{data['5m_vol_ratio']:.2f}", f"{data['5m_ema20']:.2f}", f"{data['5m_ema50']:.2f}", f"{data['5m_ema200']:.2f}",
                # 15m Timeframe
                f"{data['15m_wt1']:.2f}", f"{data['15m_wt2']:.2f}", f"{data['15m_rsi']:.2f}", f"{data['15m_mfi']:.2f}", f"{data['15m_mfi_real']:.2f}", f"{data['15m_wt_hist']:.2f}", f"{data['15m_vwap']:.2f}", f"{data['15m_vol_ratio']:.2f}", f"{data['15m_ema20']:.2f}", f"{data['15m_ema50']:.2f}", f"{data['15m_ema200']:.2f}",
                # 1h Timeframe
                f"{data['1h_wt1']:.2f}", f"{data['1h_wt2']:.2f}", f"{data['1h_rsi']:.2f}", f"{data['1h_mfi']:.2f}", f"{data['1h_mfi_real']:.2f}", f"{data['1h_wt_hist']:.2f}", f"{data['1h_vwap']:.2f}", f"{data['1h_vol_ratio']:.2f}"                f"{data['1h_ema20']:.2f}", f"{data['1h_ema50']:.2f}", f"{data['1h_ema200']:.2f}",
                # MACD Timeframes
                f"{data['1m_macd']:.2f}", f"{data['1m_macd_signal']:.2f}", f"{data['1m_macd_hist']:.2f}",
                f"{data['3m_macd']:.2f}", f"{data['3m_macd_signal']:.2f}", f"{data['3m_macd_hist']:.2f}",
                f"{data['5m_macd']:.2f}", f"{data['5m_macd_signal']:.2f}", f"{data['5m_macd_hist']:.2f}",
                f"{data['15m_macd']:.2f}", f"{data['15m_macd_signal']:.2f}", f"{data['15m_macd_hist']:.2f}",
                f"{data['1h_macd']:.2f}", f"{data['1h_macd_signal']:.2f}", f"{data['1h_macd_hist']:.2f}"
            ]
            
            with open(self.data_file, 'a', encoding='utf-8', newline='') as f:
                writer = csv.writer(f)
                writer.writerow(log_entry)
            
            print(f"📝 AI-Daten geloggt: {timestamp}")
            
        except (IOError, KeyError) as e:
            print(f"❌ AI-Logging Fehler: {e}")
    
    def log_raw_data(self, tf_name, data):
        """Schreibt Rohdaten für erweiterte Analyse."""
        try:
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            
            log_entry = [
                timestamp, 'BTC-USDT', tf_name,
                f"{data['open']:.2f}", f"{data['high']:.2f}", f"{data['low']:.2f}", f"{data['price']:.2f}",
                f"{data['volume']:.2f}", f"{data['quote_volume']:.2f}",
                f"{data['wt1']:.2f}", f"{data['wt2']:.2f}", f"{data['rsi']:.2f}", f"{data['mfi']:.2f}", f"{data['mfi_real']:.2f}",
                f"{data['wt_hist']:.2f}", f"{data['vwap']:.2f}", f"{data['volume_ratio']:.2f}",
                f"{data['ema20']:.2f}", f"{data['ema50']:.2f}", f"{data['ema200']:.2f}",
                f"{data['macd']:.2f}", f"{data['macd_signal']:.2f}", f"{data['macd_hist']:.2f}"
            ]
            
            with open(self.raw_data_file, 'a', encoding='utf-8', newline='') as f:
                writer = csv.writer(f)
                writer.writerow(log_entry)
                
        except (IOError, KeyError) as e:
            print(f"❌ Raw-Logging Fehler ({tf_name}): {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 (requests.exceptions.RequestException, KeyError) as e:
            print(f"❌ Kline Fehler ({interval}): {e}")
            return pd.DataFrame()
    
    def analyze_market_data(self, symbol='BTC-USDT'):
        """Sammelt Marktdaten für alle Timeframes - OHNE Signale."""
        analysis_data = {}
        
        for tf_name, tf_value in self.timeframes.items():
            print(f"🔄 Sammle Daten {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)
                
                latest_data = df.iloc[-1]
                
                analysis_data[tf_name] = {
                    'price': latest_data['close'],
                    'open': latest_data['open'],
                    'high': latest_data['high'],
                    'low': latest_data['low'],
                    'volume': latest_data['volume'],
                    'quote_volume': latest_data['quote_volume'],
                    'wt1': latest_data['wt1'],
                    'wt2': latest_data['wt2'],
                    'rsi': latest_data['rsi'],
                    'mfi': latest_data['mfi'],
                    'mfi_real': latest_data['mfi_real'],
                    'wt_hist': latest_data['wt_hist'],
                    'vwap': latest_data['vwap'],
                    'volume_ratio': latest_data['volume_ratio'],
                    'ema20': latest_data['ema20'],
                    'ema50': latest_data['ema50'],
                    'ema200': latest_data['ema200'],
                    'macd': latest_data['macd'],
                    'macd_signal': latest_data['macd_signal'],
                    'macd_hist': latest_data['macd_hist']
                }
                
                # Rohdaten loggen
                self.log_raw_data(tf_name, analysis_data[tf_name])
                
                print(f"✅ {tf_name} Daten gesammelt - Preis: ${latest_data['close']:.2f}")
            else:
                analysis_data[tf_name] = None
                print(f"❌ {tf_name} keine Daten (benötigt > 200 Kerzen)")
        
        return analysis_data
    
    def display_data_table(self, analysis):
        """Zeigt saubere Daten-Tabelle im Terminal an."""
        print("\n📊 MARKET DATA OVERVIEW")
        print("=" * 150)
        print(f"{'TF':<4} | {'Price':<8} | {'WT1':<6} | {'WT2':<6} | {'RSI':<5} | {'MFI':<6} | {'MFI_R':<5} | {'Volume':<10} | {'VolRatio':<8} | {'VWAP':<10} | {'EMA20':<9} | {'MACD':<9} | {'MACD_Hist':<9}")
        print("-" * 150)
        
        for tf_name in self.timeframes.keys():
            if analysis.get(tf_name):
                data = analysis[tf_name]
                
                # Volumen in lesbarem Format (M = Million, K = Tausend)
                volume_str = f"{data['volume']:,.0f}"
                if data['volume'] >= 1_000_000:
                    volume_str = f"{data['volume']/1_000_000:.1f}M"
                elif data['volume'] >= 1_000:
                    volume_str = f"{data['volume']/1_000:.1f}K"
                
                # Farbcodes
                wt1_color = "🟢" if data['wt1'] > data['wt2'] else "🔴"
                rsi_color = "🟢" if data['rsi'] < 30 else "🔴" if data['rsi'] > 70 else "🟡"
                mfi_real_color = "🟢" if data['mfi_real'] < 20 else "🔴" if data['mfi_real'] > 80 else "🟡"
                vol_color = "🟢" if data['volume_ratio'] > 1.2 else "🔴" if data['volume_ratio'] < 0.8 else "🟡"
                macd_hist_color = "🟢" if data['macd_hist'] > 0 else "🔴"
                
                print(f"{tf_name.upper():<4} | "
                      f"${data['price']:7.2f} | "
                      f"{wt1_color}{data['wt1']:5.1f} | "
                      f"{data['wt2']:5.1f} | "
                      f"{rsi_color}{data['rsi']:4.0f} | "
                      f"{data['mfi']:5.1f} | "
                      f"{mfi_real_color}{data['mfi_real']:4.0f} | "
                      f"{volume_str:>9} | "  # 👈 ABSOLUTES VOLUMEN
                      f"{vol_color}{data['volume_ratio']:7.2f}x | "
                      f"${data['vwap']:8.2f} | "
                      f"${data['ema20']:8.2f} | "
                      f"{data['macd']:8.2f} | "
                      f"{macd_hist_color}{data['macd_hist']:8.2f}")

# -----------------------------------------------------------------------------
# MAIN (Nur Datenausgabe)
# -----------------------------------------------------------------------------

def main():
    print("🚀 VuManChu AI Data Collector - Clean Market Data Output")
    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 AI DATA COLLECTOR (Pure Data Output)")
            print("=" * 70)
            print(f"🕐 {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            print()
            
            # Daten sammeln
            analysis = analyzer.analyze_market_data()
            
            # Daten im Terminal anzeigen
            analyzer.display_data_table(analysis)
            
            # AI-Daten loggen
            if all(tf in analysis and analysis[tf] for tf in analyzer.timeframes.keys()):
                log_data = {
                    'price': analysis['5m']['price'],
                    
                    # 1m Timeframe
                    '1m_wt1': analysis['1m']['wt1'], '1m_wt2': analysis['1m']['wt2'], 
                    '1m_rsi': analysis['1m']['rsi'], '1m_mfi': analysis['1m']['mfi'], '1m_mfi_real': analysis['1m']['mfi_real'],
                    '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
                    '3m_wt1': analysis['3m']['wt1'], '3m_wt2': analysis['3m']['wt2'], 
                    '3m_rsi': analysis['3m']['rsi'], '3m_mfi': analysis['3m']['mfi'], '3m_mfi_real': analysis['3m']['mfi_real'],
                    '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
                    '5m_wt1': analysis['5m']['wt1'], '5m_wt2': analysis['5m']['wt2'], 
                    '5m_rsi': analysis['5m']['rsi'], '5m_mfi': analysis['5m']['mfi'], '5m_mfi_real': analysis['5m']['mfi_real'],
                    '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
                    '15m_wt1': analysis['15m']['wt1'], '15m_wt2': analysis['15m']['wt2'], 
                    '15m_rsi': analysis['15m']['rsi'], '15m_mfi': analysis['15m']['mfi'], '15m_mfi_real': analysis['15m']['mfi_real'],
                    '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
                    '1h_wt1': analysis['1h']['wt1'], '1h_wt2': analysis['1h']['wt2'], 
                    '1h_rsi': analysis['1h']['rsi'], '1h_mfi': analysis['1h']['mfi'], '1h_mfi_real': analysis['1h']['mfi_real'],
                    '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'],

                    # MACD Timeframes
                    '1m_macd': analysis['1m']['macd'], '1m_macd_signal': analysis['1m']['macd_signal'], '1m_macd_hist': analysis['1m']['macd_hist'],
                    '3m_macd': analysis['3m']['macd'], '3m_macd_signal': analysis['3m']['macd_signal'], '3m_macd_hist': analysis['3m']['macd_hist'],
                    '5m_macd': analysis['5m']['macd'], '5m_macd_signal': analysis['5m']['macd_signal'], '5m_macd_hist': analysis['5m']['macd_hist'],
                    '15m_macd': analysis['15m']['macd'], '15m_macd_signal': analysis['15m']['macd_signal'], '15m_macd_hist': analysis['15m']['macd_hist'],
                    '1h_macd': analysis['1h']['macd'], '1h_macd_signal': analysis['1h']['macd_signal'], '1h_macd_hist': analysis['1h']['macd_hist']
                }
                
                analyzer.log_ai_data(log_data)
            
            print(f"\n📁 DATENFILES:")
            print(f"   • {analyzer.data_file} - Bereinigte AI-Daten")
            print(f"   • {analyzer.raw_data_file} - Erweiterte Rohdaten")
            print(f"\n🔄 Nächste Aktualisierung in 30s...")
            print("Drücke Ctrl+C zum Beenden")
            time.sleep(30)
            
    except KeyboardInterrupt:
        print("\n👋 AI Data Collector gestoppt")
    except (requests.exceptions.RequestException, KeyError) as e:
        print(f"\n❌ FEHLER: {e}")
        print("Stelle sicher, dass deine 'config.py' Datei existiert und korrekte Keys enthält.")


if __name__ == "__main__":
    main()