Technical Indicators

def calculate_rsi(data: pd.Series, periods: int = 14) -> pd.Series:
    """Relative Strength Index calculation"""
    
    # 1. Calculate price changes
    delta = data.diff()
    
    # 2. Separate gains and losses
    gain = delta.where(delta > 0, 0)  # Positive changes only
    loss = -delta.where(delta < 0, 0)  # Absolute value of negative changes
    
    # 3. Calculate rolling averages
    avg_gain = gain.rolling(window=periods).mean()
    avg_loss = loss.rolling(window=periods).mean()
    
    # 4. Relative strength
    rs = avg_gain / avg_loss
    
    # 5. RSI formula
    rsi = 100 - (100 / (1 + rs))
    
    return rsi

def calculate_macd(data: pd.Series, 
                   fast: int = 12, 
                   slow: int = 26, 
                   signal: int = 9) -> Tuple[pd.Series, pd.Series, pd.Series]:
    """MACD calculation"""
    
    # 1. Fast EMA (12 periods)
    exp1 = data.ewm(span=fast, adjust=False).mean()
    
    # 2. Slow EMA (26 periods)
    exp2 = data.ewm(span=slow, adjust=False).mean()
    
    # 3. MACD line = Fast EMA - Slow EMA
    macd = exp1 - exp2
    
    # 4. Signal line = 9-period EMA of MACD
    signal_line = macd.ewm(span=signal, adjust=False).mean()
    
    # 5. Histogram = MACD - Signal
    histogram = macd - signal_line
    
    return macd, signal_line, histogram

def calculate_bollinger_bands(data: pd.Series, 
                              period: int = 20, 
                              std_dev: float = 2) -> Tuple[pd.Series, pd.Series, pd.Series]:
    """Bollinger Bands calculation"""
    
    # 1. Middle band = 20-period SMA
    middle = data.rolling(window=period).mean()
    
    # 2. Standard deviation
    std = data.rolling(window=period).std()
    
    # 3. Upper band = Middle + (2 * std)
    upper = middle + (std * std_dev)
    
    # 4. Lower band = Middle - (2 * std)
    lower = middle - (std * std_dev)
    
    return upper, middle, lower

def calculate_ema(data: pd.Series, period: int) -> pd.Series:
    """Exponential Moving Average"""
    return data.ewm(span=period, adjust=False).mean()

def get_signals(df: pd.DataFrame) -> dict:
    signals = {
        'rsi_signal': 'neutral',
        'macd_signal': 'neutral',
        'bb_signal': 'neutral',
        'overall': 'neutral'
    }
    
    last_row = df.iloc[-1]
    
    # RSI Signal
    if last_row['rsi'] > 70:
        signals['rsi_signal'] = 'overbought'  # Consider selling
    elif last_row['rsi'] < 30:
        signals['rsi_signal'] = 'oversold'     # Consider buying
    
    # MACD Signal
    if last_row['macd'] > last_row['macd_signal']:
        signals['macd_signal'] = 'bullish'     # Buy signal
    else:
        signals['macd_signal'] = 'bearish'     # Sell signal
    
    # Overall Signal (consensus)
    bullish_count = sum([
        signals['rsi_signal'] == 'oversold',
        signals['macd_signal'] == 'bullish'
    ])
    
    bearish_count = sum([
        signals['rsi_signal'] == 'overbought',
        signals['macd_signal'] == 'bearish'
    ])
    
    if bullish_count >= 2:
        signals['overall'] = 'buy'      # ✅ Strong buy signal
    elif bearish_count >= 2:
        signals['overall'] = 'sell'     # ⛔ Strong sell signal
    else:
        signals['overall'] = 'neutral'  # ⚠️ No clear signal
    
    return signals

@st.cache_data(ttl=60)
def load_crypto_data(symbol, timeframe, limit):
    collector = CryptoDataCollector('kraken')
    df = collector.fetch_ohlcv(symbol, timeframe, limit)
    
    if not df.empty:
        df = TechnicalIndicators.add_all_indicators(df)  # ← All indicators added
    
    return df

INDICATORS_CONFIG = {
    'rsi_period': 14,        # RSI lookback period
    'macd_fast': 12,         # MACD fast EMA
    'macd_slow': 26,         # MACD slow EMA
    'macd_signal': 9,        # MACD signal line
    'bb_period': 20,         # Bollinger Bands period
    'bb_std': 2,             # Bollinger Bands standard deviations
    'ema_periods': [9, 21, 50, 200]  # EMA periods
}