web_app.py

from flask import Flask, render_template, request, jsonify, send_from_directory
from flask_socketio import SocketIO, emit
import requests
import time
from functools import lru_cache
import os
import threading
import json
import logging
from logging.handlers import RotatingFileHandler
from datetime import datetime, timedelta
import base64
import hmac
import hashlib

# Cryptography için import
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.backends import default_backend
CRYPTOGRAPHY_AVAILABLE = True
# Terminal encoding sorunlarını önlemek için
import sys
if sys.stdout.encoding != 'utf-8':
    import io
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')

# Config imports
from config import BINANCE_BASE_URL

print("✅ Cryptography kütüphanesi yüklendi")

# ⚡ GZIP Compression (optional - graceful fallback)
try:
    from flask_compress import Compress  # type: ignore
    COMPRESS_AVAILABLE = True
except ImportError:
    COMPRESS_AVAILABLE = False
    print("⚠️  Flask-Compress not installed. Install with: pip install Flask-Compress==1.14")

app = Flask(__name__)
socketio = SocketIO(app, cors_allowed_origins="*")

# ⚡ GZIP Compression - Response boyutu %60-70 azalır
if COMPRESS_AVAILABLE:
    compress = Compress()
    compress.init_app(app)
    app.config['COMPRESS_MIMETYPES'] = ['text/html', 'text/css', 'text/javascript', 'application/json']
    app.config['COMPRESS_LEVEL'] = 6  # 1-9 arası (6 = hız/boyut dengesi)
    app.config['COMPRESS_MIN_SIZE'] = 500  # 500 byte'dan küçük dosyaları sıkıştırma
    print("[OK] GZIP Compression enabled!")
else:
    print("[INFO] Running without compression (install Flask-Compress for better performance)")

# Disable bot-related endpoints centrally (return 410 Gone)
from flask import request

BOT_BLOCKED_PREFIXES = (
    '/api/signal_bot',
)

BOT_BLOCKED_ROUTES = {
    '/bot',
    '/api/init',
    '/api/set_demo_mode',
    '/api/status',
    '/api/add_candle',
    '/api/get_last_signal',
    '/api/apply_signal_to_bot',
    '/api/config',
    '/api/bot/config',
    '/api/bot/start',
    '/api/bot/stop',
    '/api/balance',
    '/api/balance/debug',
    '/api/close_position',
}

@app.before_request
def _disable_bot_routes():
    path = request.path or ''
    if path in BOT_BLOCKED_ROUTES or any(path.startswith(p) for p in BOT_BLOCKED_PREFIXES):
        return jsonify({'error': 'Bot features removed'}), 410

# Global semboller önbelleği
_symbols_cache = {
    'data': [],
    'timestamp': 0
}
CACHE_DURATION = 300  # 5 dakika

# Sembol minimum notional cache
_min_notional_cache = {
    'data': {},  # {symbol: min_notional}
    'timestamp': 0
}
MIN_NOTIONAL_CACHE_DURATION = 3600  # 1 saat (daha az değişir)

 

 

# Cache için timestamp tracking
_symbols_cache_time = None
_symbols_cache_lock = threading.Lock()

# Rate Limiting ve API Kontrolü
API_RATE_LIMITS = {
    'requests_per_minute': 1200,  # Binance API limiti
    'requests_per_second': 10,     # Güvenli limit
    'weight_per_minute': 6000,    # Weight limiti
    'kline_weight': 1,             # Kline çağrısı weight'i
    'ticker_weight': 1,            # Ticker çağrısı weight'i
    'order_weight': 1              # Emir çağrısı weight'i
}

# API çağrı takibi
api_call_history = []
api_weight_history = []
api_lock = threading.Lock()

def check_rate_limit(weight=1):
    """Rate limit kontrolü - Binance API limitlerini aşmamak için"""
    with api_lock:
        current_time = time.time()
        
        # Son 1 dakikadaki çağrıları temizle
        api_call_history[:] = [call_time for call_time in api_call_history if current_time - call_time < 60]
        api_weight_history[:] = [w for w in api_weight_history if current_time - w['time'] < 60]
        
        # Limitleri kontrol et
        if len(api_call_history) >= API_RATE_LIMITS['requests_per_minute']:
            sleep_time = 60 - (current_time - api_call_history[0])
            if sleep_time > 0:
                print(f"[RATE LIMIT] {sleep_time:.2f} saniye bekleniyor...")
                time.sleep(sleep_time)
        
        # Weight limitini kontrol et
        total_weight = sum(w['weight'] for w in api_weight_history)
        if total_weight + weight > API_RATE_LIMITS['weight_per_minute']:
            sleep_time = 60 - (current_time - api_weight_history[0]['time'])
            if sleep_time > 0:
                print(f"[WEIGHT LIMIT] {sleep_time:.2f} saniye bekleniyor...")
                time.sleep(sleep_time)
        
        # Çağrıyı kaydet
        api_call_history.append(current_time)
        api_weight_history.append({'time': current_time, 'weight': weight})
        
        # 1 saniye içinde çok fazla çağrı kontrolü
        recent_calls = [call_time for call_time in api_call_history if current_time - call_time < 1]
        if len(recent_calls) > API_RATE_LIMITS['requests_per_second']:
            time.sleep(1 - (current_time - recent_calls[0]))

 

 

 

 

 

 

 

 

 

 

 

 

def sign_request_hmac(params, api_secret):
    """HMAC-SHA256 ile request imzalama (eski yöntem)"""
    try:
        from urllib.parse import urlencode
        
        # Query string oluştur
        query_string = urlencode(params)
        
        # HMAC-SHA256 ile imzala
        signature = hmac.new(
            api_secret.encode('utf-8'),
            query_string.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        
        return signature
    except Exception as e:
        print(f"❌ HMAC signing error: {e}")
        return None

def sign_request_rsa(params, private_key_pem):
    """RSA Private Key ile request imzalama (yeni yöntem)"""
    try:
        from urllib.parse import urlencode
        import base64
        
        # Query string oluştur
        query_string = urlencode(params)
        
        # PEM key'in geçerli olup olmadığını kontrol et
        if not private_key_pem or len(private_key_pem.strip()) == 0:
            print("❌ PEM key boş!")
            return None
        
        if '-----BEGIN' not in private_key_pem or '-----END' not in private_key_pem:
            print("❌ Geçersiz PEM formatı! BEGIN ve END tag'leri bulunamadı.")
            return None
        
        # PEM formatındaki private key'i yükle
        try:
            # Önce standart PKCS#8 formatını dene (-----BEGIN PRIVATE KEY-----)
            private_key = serialization.load_pem_private_key(
                private_key_pem.encode('utf-8'),
                password=None,
                backend=default_backend()
            )
            print("✅ PEM key yüklendi (PKCS#8 veya PKCS#1 format)")
        except Exception as key_error:
            print(f"❌ PEM key yüklenemedi: {key_error}")
            print("📌 PEM dosyanızın formatını kontrol edin.")
            print(f"📌 PEM başlangıcı: {private_key_pem[:50]}...")
            return None
        
        # RSA ile imzala (PKCS1v15 padding kullanarak)
        # type: ignore - IDE type checker cryptography kütüphanesini tam tanımıyor
        signature_bytes = private_key.sign(  # type: ignore
            query_string.encode('utf-8'),  # type: ignore
            padding.PKCS1v15(),  # type: ignore
            hashes.SHA256()  # type: ignore
        )
        
        # Base64 encode et
        signature = base64.b64encode(signature_bytes).decode('utf-8')
        
        print(f"✅ RSA imzalama başarılı (signature length: {len(signature)})")
        return signature
    except Exception as e:
        print(f"❌ RSA signing error: {e}")
        import traceback
        traceback.print_exc()
        return None

def sign_request(params, api_secret):
    """Akıllı imzalama - RSA veya HMAC otomatik seçim"""
    # Eğer secret key PEM formatında ise RSA kullan
    if '-----BEGIN' in api_secret:
        return sign_request_rsa(params, api_secret)
    else:
        return sign_request_hmac(params, api_secret)


def get_account_balance():
    """Hesap bakiyesini al - HMAC-SHA256 authentication"""
    try:
        import time
        from urllib.parse import urlencode
        
        from config import BINANCE_API_KEY, BINANCE_API_SECRET, BINANCE_BASE_URL
        
        # API Key ve Secret kontrolü
        if not BINANCE_API_KEY:
            return {'success': False, 'error': 'API Key bulunamadı! Config dosyasını kontrol edin.'}
        
        if not BINANCE_API_SECRET:
            return {'success': False, 'error': 'API Secret bulunamadı! Config dosyasını kontrol edin.'}
        
        print(f"[INFO] API Key: {BINANCE_API_KEY[:10]}...")
        print(f"[INFO] Secret Key Format: {'PEM (RSA)' if '-----BEGIN' in BINANCE_API_SECRET else 'HMAC'}")
        
        url = f"{BINANCE_BASE_URL}/api/v3/account"
        # Binance sunucu saatini al
        server_time_response = requests.get(f"{BINANCE_BASE_URL}/api/v3/time", timeout=5)
        if server_time_response.status_code == 200:
            server_time = server_time_response.json()['serverTime']
            timestamp = server_time
        else:
            # Fallback: yerel saat
            timestamp = int(time.time() * 1000)
        
        params = {
            'timestamp': timestamp,
            'recvWindow': 10000  # 10 saniye tolerans
        }
        
        # İmzalama (RSA veya HMAC otomatik seçim)
        print(f"[INFO] İmzalama başlatılıyor...")
        signature = sign_request(params, BINANCE_API_SECRET)
        if not signature:
            return {'success': False, 'error': 'İmzalama başarısız! PEM key formatını ve cryptography kütüphanesini kontrol edin. Terminal loglarına bakın.'}
        
        params['signature'] = signature
        
        headers = {
            'X-MBX-APIKEY': BINANCE_API_KEY,
            'Content-Type': 'application/x-www-form-urlencoded'
        }
        
        print(f"[INFO] Binance API'ye istek gönderiliyor...")
        response = requests.get(url, params=params, headers=headers, timeout=10)
        
        if response.status_code == 200:
            account_data = response.json()
            balances = {}
            for balance in account_data.get('balances', []):
                free_amount = float(balance['free'])
                locked_amount = float(balance['locked'])
                # Sadece bakiyesi olan varlıkları ekle
                if free_amount > 0 or locked_amount > 0:
                    balances[balance['asset']] = {
                        'free': free_amount,
                        'locked': locked_amount
                    }
            print(f"[SUCCESS] Bakiye başarıyla alındı: {len(balances)} varlık bulundu")
            return {'success': True, 'balances': balances}
        else:
            error_msg = f"HTTP {response.status_code}"
            try:
                error_data = response.json()
                if 'msg' in error_data:
                    error_msg = f"{error_msg} - {error_data['msg']}"
            except:
                pass
            print(f"[ERROR] API Hatası: {error_msg}")
            return {'success': False, 'error': f"API Error: {error_msg}"}
            
    except Exception as e:
        print(f"[ERROR] get_account_balance exception: {e}")
        import traceback
        traceback.print_exc()
        return {'success': False, 'error': str(e)}

def get_current_price(symbol):
    """Güncel fiyatı al"""
    try:
        from config import BINANCE_BASE_URL
        url = f"{BINANCE_BASE_URL}/api/v3/ticker/price"
        params = {'symbol': symbol}
        response = requests.get(url, params=params, timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            return {'success': True, 'price': float(data['price'])}
        else:
            return {'success': False, 'error': f"API Error: {response.status_code}"}
            
    except Exception as e:
        return {'success': False, 'error': str(e)}

def get_symbol_min_notional(symbol):
    """
    Binance API'den sembol için minimum notional değerini al
    
    MIN_NOTIONAL: Alış/satış için gereken minimum işlem değeri (fiyat * miktar)
    Her coin için farklıdır:
    - BTCUSDT: ~10 USDT
    - DOGEUSDT: ~5 USDT
    - BNBUSDT: ~20 USDT
    
    Returns:
        float: Minimum notional değer (USDT cinsinden)
    """
    global _min_notional_cache
    
    try:
        # Cache kontrolü
        current_time = time.time()
        if (_min_notional_cache['timestamp'] > 0 and 
            current_time - _min_notional_cache['timestamp'] < MIN_NOTIONAL_CACHE_DURATION and
            symbol in _min_notional_cache['data']):
            
            print(f"[CACHE HIT] {symbol} min notional: {_min_notional_cache['data'][symbol]} USDT")
            return _min_notional_cache['data'][symbol]
        
        # API'den al
        from config import BINANCE_BASE_URL
        url = f"{BINANCE_BASE_URL}/api/v3/exchangeInfo"
        params = {'symbol': symbol}
        
        print(f"[API] {symbol} için exchange info çekiliyor...")
        response = requests.get(url, params=params, timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            
            if 'symbols' in data and len(data['symbols']) > 0:
                symbol_info = data['symbols'][0]
                
                # MIN_NOTIONAL filtresini bul
                for filter_item in symbol_info.get('filters', []):
                    if filter_item.get('filterType') == 'MIN_NOTIONAL':
                        min_notional = float(filter_item.get('minNotional', 10.0))
                        
                        # Cache'e kaydet
                        _min_notional_cache['data'][symbol] = min_notional
                        _min_notional_cache['timestamp'] = current_time
                        
                        print(f"[API SUCCESS] {symbol} min notional: {min_notional} USDT")
                        return min_notional
                
                # MIN_NOTIONAL bulunamazsa NOTIONAL filtresi kontrol et
                for filter_item in symbol_info.get('filters', []):
                    if filter_item.get('filterType') == 'NOTIONAL':
                        min_notional = float(filter_item.get('minNotional', 10.0))
                        
                        # Cache'e kaydet
                        _min_notional_cache['data'][symbol] = min_notional
                        _min_notional_cache['timestamp'] = current_time
                        
                        print(f"[API SUCCESS] {symbol} notional: {min_notional} USDT")
                        return min_notional
                
                print(f"[WARNING] {symbol} için MIN_NOTIONAL/NOTIONAL filtresi bulunamadı, varsayılan: 10.0 USDT")
                return 10.0
        
        print(f"[ERROR] Exchange info API hatası: {response.status_code}")
        return 10.0  # Fallback
        
    except Exception as e:
        print(f"[ERROR] Min notional alma hatası: {e}")
        return 10.0  # Fallback

def get_symbol_lot_size(symbol):
    """
    Binance API'den sembol için LOT_SIZE bilgisini al
    
    LOT_SIZE: Quantity için adım büyüklüğü (stepSize)
    Quantity bu stepSize'ın katları olmalı
    
    Örnek:
    - AVAX stepSize: 0.1 → quantity: 0.1, 0.2, 0.3, ... (0.14286 KABUL EDİLMEZ!)
    - BTC stepSize: 0.00001 → quantity: 0.00001, 0.00002, ...
    
    Returns:
        dict: {'stepSize': float, 'minQty': float, 'maxQty': float}
    """
    try:
        from config import BINANCE_BASE_URL
        url = f"{BINANCE_BASE_URL}/api/v3/exchangeInfo"
        params = {'symbol': symbol}
        
        print(f"[API] {symbol} için LOT_SIZE bilgisi çekiliyor...")
        response = requests.get(url, params=params, timeout=10)
        
        if response.status_code == 200:
            data = response.json()
            
            if 'symbols' in data and len(data['symbols']) > 0:
                symbol_info = data['symbols'][0]
                
                # LOT_SIZE filtresini bul
                for filter_item in symbol_info.get('filters', []):
                    if filter_item.get('filterType') == 'LOT_SIZE':
                        lot_size_info = {
                            'stepSize': float(filter_item.get('stepSize', 0.1)),
                            'minQty': float(filter_item.get('minQty', 0.1)),
                            'maxQty': float(filter_item.get('maxQty', 9000000.0))
                        }
                        
                        print(f"[API SUCCESS] {symbol} LOT_SIZE → stepSize: {lot_size_info['stepSize']}, minQty: {lot_size_info['minQty']}")
                        return lot_size_info
                
                print(f"[WARNING] {symbol} için LOT_SIZE filtresi bulunamadı, varsayılan kullanılıyor")
                return {'stepSize': 0.1, 'minQty': 0.1, 'maxQty': 9000000.0}
        
        print(f"[ERROR] Exchange info API hatası: {response.status_code}")
        return {'stepSize': 0.1, 'minQty': 0.1, 'maxQty': 9000000.0}
        
    except Exception as e:
        print(f"[ERROR] LOT_SIZE alma hatası: {e}")
        return {'stepSize': 0.1, 'minQty': 0.1, 'maxQty': 9000000.0}

def round_to_step_size(quantity, step_size):
    """
    Quantity'yi stepSize'a göre yuvarla
    
    Args:
        quantity: Yuvarlanacak miktar
        step_size: Adım büyüklüğü (örn: 0.1, 0.01, 0.00001)
    
    Returns:
        float: Yuvarlanmış miktar
    
    Örnek:
        round_to_step_size(0.14286, 0.1) → 0.1
        round_to_step_size(0.24286, 0.1) → 0.2
        round_to_step_size(0.123456, 0.01) → 0.12
    """
    # stepSize'ın ondalık sayısını bul
    step_str = f"{step_size:.10f}".rstrip('0')
    if '.' in step_str:
        decimals = len(step_str.split('.')[1])
    else:
        decimals = 0
    
    # Quantity'yi stepSize'ın katına yuvarla (aşağı yuvarla)
    rounded = (quantity // step_size) * step_size
    
    # Decimals'e göre format
    rounded = round(rounded, decimals)
    
    return rounded

def get_all_symbols_min_notional():
    """
    Tüm sembollerin minimum notional değerlerini toplu al
    Watchlist'teki coinler için optimize edilmiş
    
    Returns:
        dict: {symbol: min_notional}
    """
    global _min_notional_cache
    
    try:
        # Cache kontrolü
        current_time = time.time()
        if (_min_notional_cache['timestamp'] > 0 and 
            current_time - _min_notional_cache['timestamp'] < MIN_NOTIONAL_CACHE_DURATION and
            len(_min_notional_cache['data']) > 0):
            
            print(f"[CACHE HIT] Min notional cache kullanılıyor ({len(_min_notional_cache['data'])} sembol)")
            return _min_notional_cache['data']
        
        # API'den tüm sembolleri al
        from config import BINANCE_BASE_URL
        url = f"{BINANCE_BASE_URL}/api/v3/exchangeInfo"
        
        print(f"[API] Tüm semboller için exchange info çekiliyor...")
        response = requests.get(url, timeout=15)
        
        if response.status_code == 200:
            data = response.json()
            min_notionals = {}
            
            for symbol_info in data.get('symbols', []):
                symbol = symbol_info.get('symbol')
                
                # MIN_NOTIONAL filtresini bul
                for filter_item in symbol_info.get('filters', []):
                    if filter_item.get('filterType') in ['MIN_NOTIONAL', 'NOTIONAL']:
                        min_notional = float(filter_item.get('minNotional', 10.0))
                        min_notionals[symbol] = min_notional
                        break
            
            # Cache'e kaydet
            _min_notional_cache['data'] = min_notionals
            _min_notional_cache['timestamp'] = current_time
            
            print(f"[API SUCCESS] {len(min_notionals)} sembol için min notional yüklendi")
            return min_notionals
        
        print(f"[ERROR] Exchange info API hatası: {response.status_code}")
        return {}
        
    except Exception as e:
        print(f"[ERROR] Toplu min notional alma hatası: {e}")
        return {}

def send_real_order(signal, symbol, amount_usdt, max_retries=3):
    """
    Gerçek Binance API ile emir gönder - KUSURSUZ VERSİYON
    
    Args:
        signal: 'BUY' veya 'SELL' (STRING)
        symbol: Trading pair (örn: BTCUSDT)
        amount_usdt: USDT cinsinden miktar
        max_retries: Maksimum deneme sayısı
    
    Returns:
        dict: Emir sonucu
    """
    try:
        import time
        from urllib.parse import urlencode
        
        # Config'den API keyler
        from config import BINANCE_API_KEY, BINANCE_API_SECRET, BINANCE_BASE_URL, MIN_ORDER_AMOUNT_USDT, MAX_ORDER_AMOUNT_USDT, VALID_SYMBOLS
        
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        # Validasyon 1: API Key kontrolü
        if not BINANCE_API_KEY or not BINANCE_API_SECRET:
            return {'success': False, 'error': 'API anahtarları eksik! Config dosyasını kontrol edin.'}
        
        # Validasyon 2: Signal kontrolü (YENİ: STRING)
        if signal not in ['BUY', 'SELL']:
            return {'success': False, 'error': f'Geçersiz sinyal: {signal}. Sadece "BUY" veya "SELL" olabilir.'}
        
        # Validasyon 3: Amount kontrolü - CANLI MOD İÇİN (Dinamik Minimum)
        # Her coin için Binance'den minimum notional değerini al
        min_notional = get_symbol_min_notional(symbol)
        
        if amount_usdt < min_notional:
            return {'success': False, 'error': f'Emir miktarı çok düşük! {symbol} için Binance minimum: {min_notional} USDT'}
        
        if amount_usdt > MAX_ORDER_AMOUNT_USDT:
            return {'success': False, 'error': f'Emir miktarı çok yüksek! Maksimum: {MAX_ORDER_AMOUNT_USDT} USDT'}
        
        # Validasyon 4: SELL için bakiye kontrolü (CANLI MOD)
        if signal == 'SELL':
            # Gerçek bakiyede coin olup olmadığını kontrol et
            balance_result = get_account_balance()
            if balance_result['success']:
                # Symbol'den base asset çıkar (AVAXUSDT -> AVAX)
                base_asset = symbol.replace('USDT', '').replace('BUSD', '').replace('BTC', '').replace('ETH', '')
                balances = balance_result.get('balances', {})
                
                if base_asset in balances:
                    available = balances[base_asset]['free']
                    if available > 0:
                        # ✅ Bakiyede coin var, SELL yapılabilir
                        print(f"[INFO] Gerçek bakiyede {available} {base_asset} bulundu, SELL yapılacak")
                    else:
                        return {'success': False, 'error': f'{base_asset} bakiyesi yetersiz! Mevcut: {available}'}
                else:
                    return {'success': False, 'error': f'{base_asset} bakiyenizde yok!'}
            else:
                # Bakiye kontrol edilemedi
                return {'success': False, 'error': 'Bakiye kontrol edilemedi!'}
        
        # Güncel fiyatı al (retry ile)
        price_result = None
        for attempt in range(max_retries):
            price_result = get_current_price(symbol)
            if price_result['success']:
                break
            print(f"[RETRY] Fiyat alma denemesi {attempt + 1}/{max_retries}")
            time.sleep(1)
        
        if not price_result or not price_result['success']:
            return {'success': False, 'error': f"Fiyat alınamadı: {price_result.get('error') if price_result else 'Timeout'}"}
        
        current_price = price_result['price']
        
        # Emir parametreleri (signal zaten 'BUY' veya 'SELL' string)
        side = signal
        
        print(f"[{current_time}] [ORDER] {symbol} için {side} emri hazırlanıyor: {amount_usdt} USDT @ {current_price:.2f}")
        
        # Miktar hesaplama ve bakiye kontrolü (retry ile)
        balance_result = None
        for attempt in range(max_retries):
            balance_result = get_account_balance()
            if balance_result['success']:
                break
            print(f"[RETRY] Bakiye alma denemesi {attempt + 1}/{max_retries}")
            time.sleep(1)
        
        if not balance_result or not balance_result['success']:
            return {'success': False, 'error': f"Bakiye alınamadı: {balance_result.get('error') if balance_result else 'Timeout'}"}
        
        if signal == 'BUY':
            # USDT bakiyesini kontrol et
            usdt_balance = balance_result['balances'].get('USDT', {}).get('free', 0)
            
            print(f"[{current_time}] [BALANCE] Mevcut USDT: {usdt_balance:.2f}, Gerekli: {amount_usdt:.2f}")
            
            if usdt_balance < amount_usdt:
                balance_msg = f"\n{'='*80}\n"
                balance_msg += f"❌ YETERSİZ BAKİYE - BUY EMRİ GÖNDERİLEMEDİ!\n"
                balance_msg += f"{'='*80}\n"
                balance_msg += f"📅 Tarih        : {datetime.now().strftime('%d/%m/%Y')}\n"
                balance_msg += f"🕐 Saat         : {datetime.now().strftime('%H:%M:%S')}\n"
                balance_msg += f"📊 Sinyal       : BUY (ALIM)\n"
                balance_msg += f"🪙 Coin         : {symbol}\n"
                balance_msg += f"\n📌 BAKİYE DURUMU:\n"
                balance_msg += f"   ├─ Mevcut USDT  : {usdt_balance:.2f} USDT\n"
                balance_msg += f"   ├─ Gerekli      : {amount_usdt:.2f} USDT\n"
                balance_msg += f"   ├─ Eksik        : {(amount_usdt - usdt_balance):.2f} USDT\n"
                balance_msg += f"   └─ Mevcut Oran  : {(usdt_balance / amount_usdt * 100):.1f}%\n"
                balance_msg += f"\n💡 Ne Yapmalı   : USDT yükleyin veya işlem miktarını {usdt_balance:.2f} USDT'ye düşürün!\n"
                balance_msg += f"{'='*80}\n"
                
                print(balance_msg)
                
                if signal_logger:
                    signal_logger.error(f"❌ YETERSİZ BAKİYE - BUY | {symbol}")
                    signal_logger.error(f"Mevcut: {usdt_balance:.2f} USDT | Gerekli: {amount_usdt:.2f} USDT | Eksik: {(amount_usdt - usdt_balance):.2f}")
                
                if error_logger:
                    error_logger.error(f"YETERSİZ USDT BAKİYESİ: {usdt_balance:.2f} < {amount_usdt:.2f}")
                
                return {
                    'success': False, 
                    'error': f"Yetersiz USDT bakiyesi! Mevcut: {usdt_balance:.2f} USDT, Gerekli: {amount_usdt:.2f} USDT"
                }
            
            # Alınacak miktar = USDT miktarı / fiyat
            quantity = amount_usdt / current_price
            
            # ⚠️ BİNANCE LOT_SIZE FİLTRESİNE GÖRE YUVARLA
            lot_size_info = get_symbol_lot_size(symbol)
            step_size = lot_size_info['stepSize']
            min_qty = lot_size_info['minQty']
            
            # Quantity'yi stepSize'a göre yuvarla (aşağı yuvarla)
            quantity_original = quantity
            quantity = round_to_step_size(quantity, step_size)
            
            print(f"[{current_time}] [LOT_SIZE] Yuvarlanmış: {quantity_original:.8f} → {quantity:.8f} (stepSize: {step_size})")
            
            # Minimum quantity kontrolü
            if quantity < min_qty:
                return {'success': False, 'error': f'Quantity çok düşük! Minimum: {min_qty} (Hesaplanan: {quantity})'}
            
            print(f"[{current_time}] [ORDER] Alınacak miktar: {quantity} {symbol.replace('USDT', '')}")
            
        else:  # SELL
            # Base asset bakiyesini kontrol et (örn: AVAX, BTC)
            base_asset = symbol.replace('USDT', '').replace('BUSD', '').replace('BTC', '').replace('ETH', '')
            base_balance = balance_result['balances'].get(base_asset, {}).get('free', 0)
            
            # Gerçek bakiyeyi kullan
            if base_balance <= 0:
                return {'success': False, 'error': f'{base_asset} bakiyenizde yok! Mevcut: {base_balance:.6f}'}
            
            # Gerçek bakiyenin tamamını sat
            quantity = base_balance
            print(f"[{current_time}] [REAL BALANCE] Gerçek bakiyeden satılacak: {quantity:.6f} {base_asset}")
            
            # ⚠️ BİNANCE LOT_SIZE FİLTRESİNE GÖRE YUVARLA
            lot_size_info = get_symbol_lot_size(symbol)
            step_size = lot_size_info['stepSize']
            min_qty = lot_size_info['minQty']
            
            # Quantity'yi stepSize'a göre yuvarla (aşağı yuvarla)
            quantity_original = quantity
            quantity = round_to_step_size(quantity, step_size)
            
            print(f"[{current_time}] [LOT_SIZE] Yuvarlanmış: {quantity_original:.8f} → {quantity:.8f} (stepSize: {step_size})")
            
            # Minimum quantity kontrolü
            if quantity < min_qty:
                return {'success': False, 'error': f'{base_asset} miktarı çok düşük! Minimum: {min_qty} (Mevcut: {quantity})'}
            
            print(f"[{current_time}] [BALANCE] Mevcut {base_asset}: {base_balance:.6f}, Satılacak: {quantity:.6f}")
            
            if base_balance < quantity:
                balance_msg = f"\n{'='*80}\n"
                balance_msg += f"❌ YETERSİZ BAKİYE - SELL EMRİ GÖNDERİLEMEDİ!\n"
                balance_msg += f"{'='*80}\n"
                balance_msg += f"📅 Tarih        : {datetime.now().strftime('%d/%m/%Y')}\n"
                balance_msg += f"🕐 Saat         : {datetime.now().strftime('%H:%M:%S')}\n"
                balance_msg += f"📊 Sinyal       : SELL (SATIM)\n"
                balance_msg += f"🪙 Coin         : {symbol}\n"
                balance_msg += f"\n📌 BAKİYE DURUMU:\n"
                balance_msg += f"   ├─ Mevcut {base_asset:4s} : {base_balance:.6f}\n"
                balance_msg += f"   ├─ Gerekli      : {quantity:.6f}\n"
                balance_msg += f"   ├─ Eksik        : {(quantity - base_balance):.6f}\n"
                balance_msg += f"   └─ Mevcut Oran  : {(base_balance / quantity * 100):.1f}%\n"
                balance_msg += f"\n💡 Ne Yapmalı   : {base_asset} bakiyenizi kontrol edin veya pozisyon miktarını düşürün!\n"
                balance_msg += f"{'='*80}\n"
                
                print(balance_msg)
                
                if signal_logger:
                    signal_logger.error(f"❌ YETERSİZ BAKİYE - SELL | {symbol}")
                    signal_logger.error(f"Mevcut: {base_balance:.6f} {base_asset} | Gerekli: {quantity:.6f} | Eksik: {(quantity - base_balance):.6f}")
                
                if error_logger:
                    error_logger.error(f"YETERSİZ {base_asset} BAKİYESİ: {base_balance:.6f} < {quantity:.6f}")
                
                return {
                    'success': False, 
                    'error': f"Yetersiz {base_asset} bakiyesi! Mevcut: {base_balance:.6f}, Gerekli: {quantity:.6f}"
                }
        
        # Binance Spot API endpoint
        url = f"{BINANCE_BASE_URL}/api/v3/order"
        
        # Retry loop for order placement
        last_error = None
        response = None
        
        for attempt in range(max_retries):
            try:
                # Binance sunucu saatini al
                server_time_response = requests.get(f"{BINANCE_BASE_URL}/api/v3/time", timeout=5)
                if server_time_response.status_code == 200:
                    server_time = server_time_response.json()['serverTime']
                    timestamp = server_time
                else:
                    # Fallback: yerel saat
                    timestamp = int(time.time() * 1000)
                
                # Query parametreleri
                if side == "BUY":
                    # BUY için quoteOrderQty kullan (USDT cinsinden)
                    params = {
                        'symbol': symbol,
                        'side': side,
                        'type': 'MARKET',
                        'quoteOrderQty': f"{amount_usdt:.2f}",  # USDT cinsinden miktar
                        'timestamp': timestamp,
                        'recvWindow': 10000  # 10 saniye tolerans
                    }
                else:
                    # SELL için quantity kullan (base asset cinsinden)
                    # Binance precision kurallarına uygun yuvarlama (trailing zeros kaldır)
                    quantity_str = f"{quantity:.8f}".rstrip('0').rstrip('.')
                    
                    params = {
                        'symbol': symbol,
                        'side': side,
                        'type': 'MARKET',
                        'quantity': quantity_str,  # Base asset cinsinden miktar (AVAX, BTC, vs.)
                        'timestamp': timestamp,
                        'recvWindow': 10000  # 10 saniye tolerans
                    }
                    
                    print(f"[{current_time}] [ORDER] SELL emri: {quantity_str} {base_asset} (Gerçek bakiyeden)")
                
                # İmzalama (RSA veya HMAC otomatik seçim)
                signature = sign_request(params, BINANCE_API_SECRET)
                if not signature:
                    last_error = 'Request signing failed'
                    print(f"[RETRY] İmzalama hatası, deneme {attempt + 1}/{max_retries}")
                    time.sleep(1)
                    continue
                
                params['signature'] = signature
                
                # Headers
                headers = {
                    'X-MBX-APIKEY': BINANCE_API_KEY,
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
                
                print(f"[{current_time}] [ORDER] Binance API'ye emir gönderiliyor... (Deneme {attempt + 1}/{max_retries})")
                
                # POST request
                response = requests.post(url, data=params, headers=headers, timeout=15)
                
                # Başarılı response
                if response.status_code == 200:
                    break
                else:
                    last_error = f"HTTP {response.status_code}: {response.text}"
                    print(f"[RETRY] API hatası, deneme {attempt + 1}/{max_retries}: {last_error}")
                    time.sleep(2 ** attempt)  # Exponential backoff
                    
            except requests.exceptions.Timeout:
                last_error = "Request timeout"
                print(f"[RETRY] Timeout, deneme {attempt + 1}/{max_retries}")
                time.sleep(2 ** attempt)
            except Exception as e:
                last_error = str(e)
                print(f"[RETRY] Hata: {last_error}, deneme {attempt + 1}/{max_retries}")
                time.sleep(2 ** attempt)
        
        # Tüm denemeler başarısız oldu
        if not response or response.status_code != 200:
            error_msg = f"Emir gönderilemedi! Son hata: {last_error}"
            print(f"[{current_time}] [ORDER FAILED] {error_msg}")
            if signal_logger:
                signal_logger.error(f"{symbol} {side} emri başarısız: {error_msg}")
            return {'success': False, 'error': error_msg}
        
        # Başarılı emir
        order_data = response.json()
        
        # Gerçek executed fiyat ve miktar bilgilerini al
        fills = order_data.get('fills', [])
        if fills:
            # Weighted average price hesapla
            total_qty = sum(float(fill['qty']) for fill in fills)
            weighted_price = sum(float(fill['price']) * float(fill['qty']) for fill in fills) / total_qty
            executed_qty = total_qty
            executed_commission = sum(float(fill['commission']) for fill in fills)
            commission_asset = fills[0].get('commissionAsset', 'BNB')
        else:
            # Fallback to current price if fills not available
            weighted_price = current_price
            executed_qty = quantity
            executed_commission = 0
            commission_asset = 'BNB'
        
        # Log yazma - daha detaylı
        if signal == 'BUY':
            log_message = f"[{current_time}] ✅ [CANLI ALIM BAŞARILI] {symbol}\n"
            log_message += f"   └─ Miktar: {executed_qty:.6f} {symbol.replace('USDT', '')}\n"
            log_message += f"   └─ Fiyat: {weighted_price:.2f} USDT\n"
            log_message += f"   └─ Toplam: {amount_usdt:.2f} USDT\n"
            log_message += f"   └─ Komisyon: {executed_commission:.6f} {commission_asset}\n"
            log_message += f"   └─ Emir ID: {order_data.get('orderId')}"
        else:  # SELL
            log_message = f"[{current_time}] ✅ [CANLI SATIM BAŞARILI] {symbol}\n"
            log_message += f"   └─ Miktar: {executed_qty:.6f} {symbol.replace('USDT', '')}\n"
            log_message += f"   └─ Fiyat: {weighted_price:.2f} USDT\n"
            log_message += f"   └─ Komisyon: {executed_commission:.6f} {commission_asset}\n"
            log_message += f"   └─ Emir ID: {order_data.get('orderId')}"
        
        print(log_message)
        if signal_logger:
            signal_logger.info(log_message)
        
        # Return dictionary
        result = {
            'success': True,
            'orderId': order_data.get('orderId'),
            'status': order_data.get('status'),
            'price': weighted_price,
            'quantity': executed_qty,
            'amount_usdt': amount_usdt,
            'commission': executed_commission,
            'commission_asset': commission_asset,
            'data': order_data
        }
        
        return result
            
    except Exception as e:
        error_msg = str(e)
        print(f"[{current_time}] [CANLI HATA] {symbol} emri hatası: {error_msg}")
        if signal_logger:
            signal_logger.error(f"{symbol} emri hatası: {error_msg}")
        
        return {
            'success': False,
            'error': error_msg
        }

def calculate_ssl_hybrid_signals(klines):
    """
    SSL Hybrid stratejisi ile sinyal hesaplama
    
    Args:
        klines: Binance kline verisi
        
    Returns:
        dict: Sinyal bilgileri
    """
    try:
        if len(klines) < 20:  # En az 20 mum gerekli (test için)
            return {
                'signal': 0,
                'signal_text': 'NONE',
                'trend': 'Beklemede',
                'baseline': 0,
                'ssl1': 0,
                'ssl2': 0,
                'exit': 0
            }
        
        # Tüm mumları kullan (1000 mum)
        recent_klines = klines
        
        # OHLCV verilerini çıkar
        highs = [float(k[2]) for k in recent_klines]
        lows = [float(k[3]) for k in recent_klines]
        closes = [float(k[4]) for k in recent_klines]
        opens = [float(k[1]) for k in recent_klines]
        
        # SSL Hybrid parametreleri
        ssl1_len = 60
        ssl2_len = 5
        exit_len = 15
        atr_len = 14
        
        # HMA hesaplama fonksiyonu
        def calc_hma(values, period):
            if len(values) < period:
                return [0] * len(values)
            
            # WMA hesaplama
            def calc_wma(data, length):
                result = []
                for i in range(len(data)):
                    if i < length - 1:
                        result.append(0)
                    else:
                        weights = list(range(1, length + 1))
                        weight_sum = sum(weights)
                        weighted_sum = sum(data[i - length + 1 + j] * weights[j] for j in range(length))
                        result.append(weighted_sum / weight_sum)
                return result
            
            half_period = period // 2
            sqrt_period = int(period ** 0.5)
            
            wma1 = calc_wma(values, half_period)
            wma2 = calc_wma(values, period)
            
            raw_hma = [2 * wma1[i] - wma2[i] if wma1[i] != 0 and wma2[i] != 0 else 0 for i in range(len(values))]
            return calc_wma(raw_hma, sqrt_period)
        
        # EMA hesaplama
        def calc_ema(values, period):
            if len(values) < period:
                return [0] * len(values)
            
            k = 2 / (period + 1)
            result = [values[0]]
            for i in range(1, len(values)):
                ema = (values[i] - result[-1]) * k + result[-1]
                result.append(ema)
            return result
        
        # ATR hesaplama
        def calc_atr(highs, lows, closes, period):
            if len(highs) < 2:
                return [0] * len(highs)
            
            tr = [highs[0] - lows[0]]
            for i in range(1, len(highs)):
                tr1 = highs[i] - lows[i]
                tr2 = abs(highs[i] - closes[i-1])
                tr3 = abs(lows[i] - closes[i-1])
                tr.append(max(tr1, tr2, tr3))
            
            return calc_ema(tr, period)
        
        # SSL Channel hesaplama
        def calc_ssl_channel(highs, lows, closes, period):
            ema_high = calc_ema(highs, period)
            ema_low = calc_ema(lows, period)
            
            hlv = [1]
            ssl_down = [ema_high[0]]
            ssl_up = [ema_low[0]]
            
            for i in range(1, len(closes)):
                if closes[i] > ema_high[i]:
                    hlv.append(1)
                elif closes[i] < ema_low[i]:
                    hlv.append(-1)
                else:
                    hlv.append(hlv[-1])
                
                ssl_down.append(ema_high[i] if hlv[i] < 0 else ema_low[i])
                ssl_up.append(ema_low[i] if hlv[i] < 0 else ema_high[i])
            
            return ssl_down, ssl_up, hlv
        
        # Baseline (HMA of close)
        baseline = calc_hma(closes, ssl1_len)
        
        # SSL1 (HMA)
        ssl1_down, ssl1_up, hlv1 = calc_ssl_channel(highs, lows, closes, ssl1_len)
        
        # SSL2 (EMA)
        ssl2_down, ssl2_up, hlv2 = calc_ssl_channel(highs, lows, closes, ssl2_len)
        
        # Exit (HMA)
        exit_down, exit_up, hlv_exit = calc_ssl_channel(highs, lows, closes, exit_len)
        
        # ATR
        atr = calc_atr(highs, lows, closes, atr_len)
        
        # Son değerl
        current_close = closes[-1]
        current_baseline = baseline[-1]
        current_ssl1 = ssl1_down[-1]
        current_ssl2 = ssl2_down[-1]
        current_exit = exit_down[-1]
        
        # Sinyal hesaplama - Geliştirilmiş mantık
        signal = 0
        signal_text = 'NONE'
        trend = 'Beklemede'
        
        # SSL1 vs SSL2 trend analizi
        ssl1_trend = current_ssl1 > current_ssl2
        ssl2_trend = current_ssl2 > current_ssl1
        
        # Exit line cross kontrolü
        if len(closes) > 1:
            prev_close = closes[-2]
            prev_exit = exit_down[-2]
            
            # Cross above exit line (BUY sinyali)
            if current_close > current_exit and prev_close <= prev_exit:
                signal = 1  # BUY
                signal_text = 'BUY'
                trend = 'Yükseliş'
            # Cross below exit line (SELL sinyali)  
            elif current_close < current_exit and prev_close >= prev_exit:
                signal = -1  # SELL
                signal_text = 'SELL'
                trend = 'Düşüş'
            # Mevcut pozisyon kontrolü
            elif current_close > current_exit * 1.002:  # %0.2 üstünde kalıyorsa
                signal = 1  # BUY
                signal_text = 'BUY'
                trend = 'Yükseliş'
            elif current_close < current_exit * 0.998:  # %0.2 altında kalıyorsa
                signal = -1  # SELL
                signal_text = 'SELL'
                trend = 'Düşüş'
            else:
                # Trend analizi (SSL1 vs SSL2)
                if ssl1_trend and current_close > current_baseline:
                    signal = 1  # BUY
                    signal_text = 'BUY'
                    trend = 'Yükseliş'
                elif ssl2_trend and current_close < current_baseline:
                    signal = -1  # SELL
                    signal_text = 'SELL'
                    trend = 'Düşüş'
        
        # Sinyal loglama
        print(f"[SSL] Sinyal: {signal_text} | Trend: {trend} | Close: {current_close:.2f} | Exit: {current_exit:.2f}")
        
        return {
            'signal': signal,
            'signal_text': signal_text,
            'trend': trend,
            'baseline': current_baseline,
            'ssl1': current_ssl1,
            'ssl2': current_ssl2,
            'exit': current_exit
        }
        
    except Exception as e:
        print(f"[ERROR] SSL Hybrid hesaplama hatası: {e}")
        return {
            'signal': 0,
            'signal_text': 'NONE',
            'trend': 'Hata',
            'baseline': 0,
            'ssl1': 0,
            'ssl2': 0,
            'exit': 0
        }

def setup_logging():
    """Log rotasyonu ve dosya yönetimi - Uzun süreli testler için"""
    try:
        # Log klasörü oluştur
        log_dir = 'logs'
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)
        
        # Ana log dosyası - 10MB, 5 dosya (UTF-8 encoding)
        main_handler = RotatingFileHandler(
            f'{log_dir}/bot_main.log', 
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5,
            encoding='utf-8'
        )
        main_handler.setLevel(logging.INFO)
        main_formatter = logging.Formatter(
            '%(asctime)s - %(levelname)s - %(message)s'
        )
        main_handler.setFormatter(main_formatter)
        
        # Bot analiz log dosyası - 5MB, 3 dosya (UTF-8 encoding)
        analysis_handler = RotatingFileHandler(
            f'{log_dir}/bot_analysis.log', 
            maxBytes=5*1024*1024,  # 5MB
            backupCount=3,
            encoding='utf-8'
        )
        analysis_handler.setLevel(logging.INFO)
        analysis_formatter = logging.Formatter(
            '%(asctime)s - %(message)s'
        )
        analysis_handler.setFormatter(analysis_formatter)
        
        # Error log dosyası - 2MB, 2 dosya (UTF-8 encoding)
        error_handler = RotatingFileHandler(
            f'{log_dir}/bot_errors.log', 
            maxBytes=2*1024*1024,  # 2MB
            backupCount=2,
            encoding='utf-8'
        )
        error_handler.setLevel(logging.ERROR)
        error_formatter = logging.Formatter(
            '%(asctime)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s'
        )
        error_handler.setFormatter(error_formatter)
        
        # Sinyal bot log dosyası - 5MB, 3 dosya (UTF-8 encoding)
        signal_handler = RotatingFileHandler(
            f'{log_dir}/signal_bot.log', 
            maxBytes=5*1024*1024,  # 5MB
            backupCount=3,
            encoding='utf-8'
        )
        signal_handler.setLevel(logging.INFO)
        signal_formatter = logging.Formatter(
            '%(asctime)s - [SİNYAL BOT] - %(message)s'
        )
        signal_handler.setFormatter(signal_formatter)
        
        # Logger'ları yapılandır
        main_logger = logging.getLogger('bot_main')
        main_logger.setLevel(logging.INFO)
        main_logger.addHandler(main_handler)
        
        analysis_logger = logging.getLogger('bot_analysis')
        analysis_logger.setLevel(logging.INFO)
        analysis_logger.addHandler(analysis_handler)
        
        error_logger = logging.getLogger('bot_errors')
        error_logger.setLevel(logging.ERROR)
        error_logger.addHandler(error_handler)
        
        # Sinyal bot logger
        signal_logger = logging.getLogger('signal_bot')
        signal_logger.setLevel(logging.INFO)
        signal_logger.addHandler(signal_handler)
        
        print("[LOGGING] Log sistemi başlatıldı - Rotasyon aktif")
        return main_logger, analysis_logger, error_logger, signal_logger
        
    except Exception as e:
        print(f"[ERROR] Log sistemi hatası: {e}")
        return None, None, None, None

# Log sistemini başlat
main_logger, analysis_logger, error_logger, signal_logger = setup_logging()

# Terminal çıktılarını log dosyasına yazdırmak için print() override
import sys
from io import StringIO

class TerminalLogger:
    """Terminal çıktılarını log dosyasına yazdıran sınıf"""
    def __init__(self):
        self.original_stdout = sys.stdout
        self.terminal_logs = []
        self.max_logs = 1000  # Maksimum log sayısı
        
    def write(self, message):
        # Orijinal stdout'a yaz (terminal'de görünür)
        self.original_stdout.write(message)
        self.original_stdout.flush()
        
        # Log dosyasına da yaz
        if message.strip():  # Boş satırları yoksay
            timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            log_entry = f"[{timestamp}] {message.strip()}"
            
            # Terminal loglarına ekle
            self.terminal_logs.append({
                'timestamp': timestamp,
                'message': message.strip(),
                'level': 'INFO'
            })
            
            # Maksimum log sayısını aş
            if len(self.terminal_logs) > self.max_logs:
                self.terminal_logs = self.terminal_logs[-self.max_logs:]
            
            # Signal logger'a da yaz
            if signal_logger:
                signal_logger.info(message.strip())
    
    def flush(self):
        self.original_stdout.flush()
    
    def get_logs(self, lines=100):
        """Son N satır terminal logunu getir"""
        return self.terminal_logs[-lines:] if len(self.terminal_logs) > lines else self.terminal_logs

# Terminal logger ve bot analiz döngüsü kaldırıldı

@lru_cache(maxsize=1)
def _fetch_symbols_from_api_cached(cache_key):
    """Binance'tan tüm işlem çiftlerini çeker (önbelleklenmiş)"""
    url = "https://api.binance.com/api/v3/exchangeInfo"
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        data = response.json()
        symbols = data["symbols"]
        # Sadece aktif sembolleri al (performans için)
        active_symbols = [s["symbol"] for s in symbols if s["status"] == "TRADING"]
        return tuple(active_symbols)
    except Exception as e:
        print(f"Error fetching symbols: {e}")
        return tuple([])

def _fetch_symbols_from_api():
    """5 dakikada bir cache'i yenileyen wrapper"""
    global _symbols_cache_time
    
    with _symbols_cache_lock:
        now = datetime.now()
        # 5 dakikadan eskiyse yenile
        if _symbols_cache_time is None or (now - _symbols_cache_time) > timedelta(minutes=5):
            _symbols_cache_time = now
            # Cache key olarak timestamp kullan (5dk'da bir değişir)
            cache_key = int(now.timestamp() / 300)  # 300 saniye = 5dk
            _fetch_symbols_from_api_cached.cache_clear()
            return _fetch_symbols_from_api_cached(cache_key)
        
        # Mevcut cache'i döndür
        cache_key = int(_symbols_cache_time.timestamp() / 300)
        return _fetch_symbols_from_api_cached(cache_key)

def get_all_symbols():
    """Binance'tan tüm işlem çiftlerini çeker (önbellekli)"""
    # 5 dakikadan eskiyse yeni veri çek
    symbols_tuple = _fetch_symbols_from_api()
    return list(symbols_tuple)

def get_turkish_stocks():
    """Binance TR'den hisse senetlerini çeker"""
    # Gerçek Binance TR API'sinden hisse senetlerini çek
    try:
        url = "https://api.binance.com/api/v3/exchangeInfo"
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        data = response.json()
        
        # Türkiye hisselerini filtrele (TRY ile bitenler)
        turkish_stocks = []
        for symbol_info in data.get("symbols", []):
            symbol = symbol_info["symbol"]
            if symbol.endswith("TRY"):
                turkish_stocks.append(symbol)
                
        # Eğer TRY ile biten sembol yoksa, örnek veriler sağla
        if not turkish_stocks:
            turkish_stocks = [
                "THYAO.TRY",
                "GARAN.TRY",
                "AKBNK.TRY",
                "EREGL.TRY",
                "KRDMD.TRY",
                "YKBNK.TRY",
                "SAHOL.TRY",
                "TUPRS.TRY",
                "PETKM.TRY",
                "KCHOL.TRY"
            ]
            
        return turkish_stocks
    except Exception as e:
        print(f"Error fetching Turkish stocks: {e}")
        # Hata durumunda örnek verileri döndür
        return [
            "THYAO.TRY",
            "GARAN.TRY",
            "AKBNK.TRY",
            "EREGL.TRY",
            "KRDMD.TRY",
            "YKBNK.TRY",
            "SAHOL.TRY",
            "TUPRS.TRY",
            "PETKM.TRY",
            "KCHOL.TRY"
        ]

def find_symbols_by_prefix(prefix, symbols):
    """Verilen önek ile eşleşen tüm sembolleri bulur"""
    if not prefix:
        return symbols[:50]  # İlk 50 sembolü döndür
    
    prefix = prefix.strip().lower()
    matches = []
    
    # Önce kripto paraları ara
    for s in symbols:
        # Sembolü küçük harfe çevir
        symbol_lower = s.lower()
        
        # USDT, BTC, ETH, BNB ile biten semboller için coin adını çıkar
        coin_name = symbol_lower
        for suffix in ["usdt", "btc", "eth", "bnb"]:
            if symbol_lower.endswith(suffix):
                coin_name = symbol_lower[:-len(suffix)]
                break
        
        # Önek ile başlayanları veya içerenleri bul
        if coin_name.startswith(prefix) or prefix in coin_name:
            matches.append(s)
        
        # 15 sonuç bulunca dur
        if len(matches) >= 15:
            break
    
    return matches

def find_symbols_by_prefix_stocks(prefix, symbols):
    """Verilen önek ile eşleşen hisse sembollerini bulur"""
    if not prefix:
        return symbols[:20]  # İlk 20 sembolü döndür
    
    prefix = prefix.strip().lower()
    matches = []
    
    # Hisse senetlerini ara
    for s in symbols:
        if s.lower().startswith(prefix) or prefix in s.lower():
            matches.append(s)
            if len(matches) >= 20:
                break
            
    return matches

def find_symbol(user_input, symbols):
    """Kullanıcının girdiği coin adını uygun Binance sembolüne dönüştürür"""
    name = user_input.strip().lower()
    
    # Önce tam eşleşmeleri kontrol et
    for s in symbols:
        if s.lower() == name:
            return s
    
    # USDT ile bitenleri kontrol et
    for s in symbols:
        if s.lower() == name + "usdt":
            return s
            
    # Diğer işlem çiftlerini kontrol et
    for s in symbols:
        base_coin = s.lower()
        # USDT, BTC, ETH, BNB ile bitenleri kontrol et
        if base_coin.startswith(name):
            return s
    
    # USDT, BTC, ETH, BNB ile biten coin adlarını kontrol et
    for suffix in ["usdt", "btc", "eth", "bnb"]:
        candidate = name.upper() + suffix.upper()
        if candidate in symbols:
            return candidate
            
    return None

def find_stock_symbol(user_input, symbols):
    """Kullanıcının girdiği hisse adını uygun Binance sembolüne dönüştürür"""
    name = user_input.strip().lower()
    
    # Önce tam eşleşmeleri kontrol et
    for s in symbols:
        if s.lower() == name:
            return s
    
    # TRY ile bitenleri kontrol et
    for s in symbols:
        if s.lower() == name + ".try":
            return s
            
    # Nokta olmadan deneyin
    for s in symbols:
        if s.lower().startswith(name + "."):
            return s
            
    return None

@lru_cache(maxsize=128)
def _fetch_detailed_data_cached(symbol):
    """Belirli bir sembolün detaylı verilerini çeker (önbelleklenmiş)"""
    # Kitaplık fiyatı (anlık alış/satış)
    book_url = "https://api.binance.com/api/v3/ticker/bookTicker"
    # 24 saatlik istatistikler
    stats_url = "https://api.binance.com/api/v3/ticker/24hr"
    # 1 saatlik kline verileri
    klines_url = "https://api.binance.com/api/v3/klines"
    # Sembol bilgileri
    exchange_info_url = "https://api.binance.com/api/v3/exchangeInfo"
    
    try:
        # Kitaplık verisini çek
        book_response = requests.get(book_url, params={"symbol": symbol}, timeout=3)
        book_response.raise_for_status()
        book_data = book_response.json()
        
        # 24 saatlik istatistikleri çek
        stats_response = requests.get(stats_url, params={"symbol": symbol}, timeout=3)
        stats_response.raise_for_status()
        stats_data = stats_response.json()
        
        # 1 saatlik kline verilerini çek (son 24 saat için 24 mum)
        klines_response = requests.get(klines_url, params={
            "symbol": symbol,
            "interval": "1h",
            "limit": 24
        }, timeout=3)
        klines_response.raise_for_status()
        klines_data = klines_response.json()
        
        # Sembol bilgilerini çek
        exchange_response = requests.get(exchange_info_url, params={"symbol": symbol}, timeout=3)
        exchange_response.raise_for_status()
        exchange_data = exchange_response.json()
        
        symbol_info = None
        if "symbols" in exchange_data and len(exchange_data["symbols"]) > 0:
            symbol_info = exchange_data["symbols"][0]
        
        return (
            book_data["symbol"],
            float(book_data["bidPrice"]),
            float(book_data["askPrice"]),
            float(stats_data["lastPrice"]),
            float(stats_data["priceChange"]),
            float(stats_data["priceChangePercent"]),
            float(stats_data["highPrice"]),
            float(stats_data["lowPrice"]),
            float(stats_data["volume"]),
            float(stats_data["quoteVolume"]),
            klines_data,
            symbol_info
        )
    except Exception as e:
        raise e

def get_detailed_data(symbol):
    """Belirli bir sembolün detaylı verilerini döndürür"""
    # Önbelleği devre dışı bırakarak doğrudan veri çek
    try:
        # Kitaplık fiyatı (anlık alış/satış)
        book_url = "https://api.binance.com/api/v3/ticker/bookTicker"
        # 24 saatlik istatistikler
        stats_url = "https://api.binance.com/api/v3/ticker/24hr"
        # 1 saatlik kline verileri
        klines_url = "https://api.binance.com/api/v3/klines"
        # Sembol bilgileri
        exchange_info_url = "https://api.binance.com/api/v3/exchangeInfo"
        
        # Kitaplık verisini çek
        book_response = requests.get(book_url, params={"symbol": symbol}, timeout=3)
        book_response.raise_for_status()
        book_data = book_response.json()
        
        # 24 saatlik istatistikleri çek
        stats_response = requests.get(stats_url, params={"symbol": symbol}, timeout=3)
        stats_response.raise_for_status()
        stats_data = stats_response.json()
        
        # 1 saatlik kline verilerini çek (son 24 saat için 24 mum)
        klines_response = requests.get(klines_url, params={
            "symbol": symbol,
            "interval": "1h",
            "limit": 24
        }, timeout=3)
        klines_response.raise_for_status()
        klines_data = klines_response.json()
        
        # Sembol bilgilerini çek
        exchange_response = requests.get(exchange_info_url, params={"symbol": symbol}, timeout=3)
        exchange_response.raise_for_status()
        exchange_data = exchange_response.json()
        
        symbol_info = None
        if "symbols" in exchange_data and len(exchange_data["symbols"]) > 0:
            symbol_info = exchange_data["symbols"][0]
        
        return {
            "symbol": book_data["symbol"],
            "bid": float(book_data["bidPrice"]),  # Alış fiyatı
            "ask": float(book_data["askPrice"]),  # Satış fiyatı
            "last_price": float(stats_data["lastPrice"]),  # Son işlem fiyatı
            "price_change": float(stats_data["priceChange"]),  # Fiyat değişim miktarı
            "price_change_percent": float(stats_data["priceChangePercent"]),  # Fiyat değişim yüzdesi
            "high_price": float(stats_data["highPrice"]),  # 24 saatlik en yüksek fiyat
            "low_price": float(stats_data["lowPrice"]),  # 24 saatlik en düşük fiyat
            "volume": float(stats_data["volume"]),  # 24 saatlik hacim
            "quote_volume": float(stats_data["quoteVolume"]),  # 24 saatlik hacim (quote cinsinden)
            "klines": klines_data,  # 1 saatlik kline verileri
            "symbol_info": symbol_info  # Sembol bilgileri
        }
    except Exception as e:
        return {"error": str(e)}

def get_detailed_data_with_timeframe(symbol, timeframe="1h"):
    """Belirli bir sembolün detaylı verilerini belirtilen zaman dilimi ile döndürür"""
    try:
        print(f"get_detailed_data_with_timeframe çağrıldı: symbol={symbol}, timeframe={timeframe}")
        
        # Kitaplık fiyatı (anlık alış/satış)
        book_url = "https://api.binance.com/api/v3/ticker/bookTicker"
        # 24 saatlik istatistikler
        stats_url = "https://api.binance.com/api/v3/ticker/24hr"
        # Kline verileri
        klines_url = "https://api.binance.com/api/v3/klines"
        # Sembol bilgileri
        exchange_info_url = "https://api.binance.com/api/v3/exchangeInfo"
        
        # Zaman dilimine göre limit belirle
        timeframe_limits = {
            "1m": 1440,   # 24 saat = 1440 dakika
            "5m": 288,    # 24 saat = 288 * 5 dakika
            "15m": 96,    # 24 saat = 96 * 15 dakika
            "30m": 48,    # 24 saat = 48 * 30 dakika
            "1h": 24,     # 24 saat = 24 * 1 saat
            "4h": 168,    # 28 gün = 168 * 4 saat
            "1d": 30,     # 30 gün
            "1w": 12,     # 12 hafta
            "1M": 12      # 12 ay
        }
        
        limit = timeframe_limits.get(timeframe, 24)
        print(f"Limit belirlendi: {limit}")
        
        # Paralel API çağrıları için session oluştur
        session = requests.Session()
        
        # Kitaplık verisini çek
        book_response = session.get(book_url, params={"symbol": symbol}, timeout=5)
        book_response.raise_for_status()
        book_data = book_response.json()
        
        # 24 saatlik istatistikleri çek
        stats_response = session.get(stats_url, params={"symbol": symbol}, timeout=5)
        stats_response.raise_for_status()
        stats_data = stats_response.json()
        
        # Kline verilerini çek
        klines_response = session.get(klines_url, params={
            "symbol": symbol,
            "interval": timeframe,
            "limit": limit
        }, timeout=8)
        klines_response.raise_for_status()
        klines_data = klines_response.json()
        print(f"Kline verileri alındı: {len(klines_data)} adet")
        
        # Sembol bilgilerini çek (opsiyonel, hata olursa devam et)
        try:
            exchange_response = session.get(exchange_info_url, params={"symbol": symbol}, timeout=3)
            exchange_response.raise_for_status()
            exchange_data = exchange_response.json()
        except Exception as e:
            print(f"Sembol bilgisi alınamadı: {e}")
            exchange_data = {"symbols": []}
        
        symbol_info = None
        if "symbols" in exchange_data and len(exchange_data["symbols"]) > 0:
            symbol_info = exchange_data["symbols"][0]
        
        return {
            "symbol": book_data["symbol"],
            "bid": float(book_data["bidPrice"]),
            "ask": float(book_data["askPrice"]),
            "last_price": float(stats_data["lastPrice"]),
            "price_change": float(stats_data["priceChange"]),
            "price_change_percent": float(stats_data["priceChangePercent"]),
            "high_price": float(stats_data["highPrice"]),
            "low_price": float(stats_data["lowPrice"]),
            "volume": float(stats_data["volume"]),
            "quote_volume": float(stats_data["quoteVolume"]),
            "klines": klines_data,
            "symbol_info": symbol_info,
            "timeframe": timeframe
        }
    except Exception as e:
        return {"error": str(e)}

# Hisse senetleri için özel fiyat alma fonksiyonu
def get_stock_price(symbol):
    """Hisse senetleri için fiyat bilgisi çeker"""
    try:
        # Hisse senetleri için de aynı Binance API'sini kullanabiliriz
        # Çünkü Binance TR hisseleri de aynı API üzerinden sunuluyor
        return get_detailed_data(symbol)
    except Exception as e:
        return {"error": f"Hisse fiyatı alınırken hata oluştu: {str(e)}"}

@app.route('/favicon.ico')
def favicon():
    return send_from_directory('static', 'favicon.ico', mimetype='image/vnd.microsoft.icon')

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/stocks')
def stocks():
    return render_template('stocks.html')

@app.route('/tradingview')
def tradingview_chart():
    return render_template('tradingview_chart.html')

@app.route('/realtime')
def realtime_chart():
    """Detaylı grafik sayfası - Gerçek zamanlı 1 saniyede güncelleme"""
    return render_template('realtime_chart.html')


@app.route('/api/symbols')
def api_symbols():
    symbols = get_all_symbols()
    return jsonify(symbols)

@app.route('/api/search_symbols', methods=['GET'])
def api_search_symbols():
    prefix = request.args.get('prefix', '')
    symbol_type = request.args.get('type', 'crypto')
    
    if symbol_type == 'stock':
        # Hisse senetleri için öneriler
        stocks = get_turkish_stocks()
        matches = find_symbols_by_prefix_stocks(prefix, stocks)
        return jsonify(matches)
    else:
        # Kripto paralar için öneriler
        symbols = get_all_symbols()
        matches = find_symbols_by_prefix(prefix, symbols)
        return jsonify(matches)

@app.route('/api/price', methods=['POST'])
def api_price():
    data = request.get_json()
    user_input = data.get('coin', '')
    
    if not user_input:
        return jsonify({"error": "Coin adı gerekli"}), 400
    
    symbols = get_all_symbols()
    symbol = find_symbol(user_input, symbols)
    
    if not symbol:
        return jsonify({"error": f"'{user_input}' için uygun sembol bulunamadı"}), 404
    
    result = get_detailed_data(symbol)
    return jsonify(result)

@app.route('/api/price_with_timeframe', methods=['POST'])
def api_price_with_timeframe():
    try:
        data = request.get_json()
        user_input = data.get('coin', '')
        timeframe = data.get('timeframe', '1h')
        
        print(f"API isteği alındı: coin={user_input}, timeframe={timeframe}")
        
        if not user_input:
            return jsonify({"error": "Coin adı gerekli"}), 400
        
        symbols = get_all_symbols()
        symbol = find_symbol(user_input, symbols)
        
        if not symbol:
            return jsonify({"error": f"'{user_input}' için uygun sembol bulunamadı"}), 404
        
        print(f"Sembol bulundu: {symbol}, zaman dilimi: {timeframe}")
        
        result = get_detailed_data_with_timeframe(symbol, timeframe)
        
        if 'error' in result:
            print(f"Hata oluştu: {result['error']}")
        else:
            print(f"Başarılı: {len(result.get('klines', []))} kline verisi")
        
        return jsonify(result)
    except Exception as e:
        print(f"API hatası: {str(e)}")
        return jsonify({"error": f"Sunucu hatası: {str(e)}"}), 500

# Hisse senetleri için özel API endpoint
@app.route('/api/stock_price', methods=['POST'])
def api_stock_price():
    data = request.get_json()
    symbol = data.get('symbol', '')
    
    if not symbol:
        return jsonify({"error": "Hisse sembolü gerekli"}), 400
    
    # Hisse senetleri listesini al
    stocks = get_turkish_stocks()
    
    # Sembolün geçerli olup olmadığını kontrol et
    found_symbol = find_stock_symbol(symbol, stocks)
    
    if not found_symbol:
        return jsonify({"error": f"'{symbol}' geçerli bir hisse sembolü değil"}), 404
    
    result = get_stock_price(found_symbol)
    return jsonify(result)

@app.route('/api/indicators', methods=['POST'])
def api_indicators():
    data = request.get_json()
    symbol = data.get('symbol', '')
    
    if not symbol:
        return jsonify({"error": "Sembol gerekli"}), 400
    
    try:
        # Kline verilerini al
        klines_url = "https://api.binance.com/api/v3/klines"
        klines_response = requests.get(klines_url, params={
            "symbol": symbol,
            "interval": "1h",
            "limit": 50  # Daha fazla veri almak için limiti artırıyoruz
        }, timeout=5)
        klines_response.raise_for_status()
        klines_data = klines_response.json()
        
        if not klines_data:
            return jsonify({"error": "Kline verisi bulunamadı"}), 404
        
        # Kapanış fiyatlarını al (kline verisinin 4. indeksi)
        closing_prices = [float(kline[4]) for kline in klines_data]
        
        # 24 periyotluk hareketli ortalama hesapla
        if len(closing_prices) >= 24:
            moving_average = sum(closing_prices[-24:]) / 24
        else:
            moving_average = sum(closing_prices) / len(closing_prices) if closing_prices else 0
        
        # 14 periyotluk RSI hesapla
        rsi = calculate_rsi(closing_prices, 14)
        
        # Trend belirleme (basit yaklaşım: son 24 saatlik MA ile önceki 24 saatlik MA karşılaştırması)
        if len(closing_prices) >= 48:
            prev_ma = sum(closing_prices[-48:-24]) / 24
            current_ma = sum(closing_prices[-24:]) / 24
            trend = "Yukarı trend" if current_ma > prev_ma else "Aşağı trend"
        else:
            # Yeterli veri yoksa son birkaç kapanışa bak
            if len(closing_prices) >= 2:
                trend = "Yukarı trend" if closing_prices[-1] > closing_prices[-2] else "Aşağı trend"
            else:
                trend = "Belirsiz"
        
        return jsonify({
            "symbol": symbol,
            "moving_average": moving_average,
            "rsi": rsi,
            "trend": trend
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/klines', methods=['GET'])
def api_klines():
    """API endpoint to fetch kline data from Binance - OPTIMIZED"""
    symbol = request.args.get('symbol', 'BTCUSDT')
    interval = request.args.get('interval', '1m')
    limit = int(request.args.get('limit', 1000))
    start_time = request.args.get('startTime', None)
    compact = request.args.get('compact', 'false').lower() == 'true'  # Yeni: compact mode
    
    try:
        # Fetch data from Binance API
        klines_url = "https://api.binance.com/api/v3/klines"
        params = {
            "symbol": symbol,
            "interval": interval,
            "limit": min(limit, 1000)  # Max 1000 limit koy
        }
        
        # Eğer startTime verilmişse ekle (incremental update için)
        if start_time:
            params["startTime"] = start_time
        
        klines_response = requests.get(klines_url, params=params, timeout=10)
        
        # Binance API hata kontrolü
        if klines_response.status_code != 200:
            error_data = klines_response.json() if klines_response.text else {}
            error_msg = error_data.get('msg', 'Bilinmeyen hata')
            error_code = error_data.get('code', klines_response.status_code)
            
            print(f"❌ Klines API Hatası: {symbol} - Code: {error_code} - Msg: {error_msg}")
            
            # Özel hata mesajları
            if error_code == -1121 or 'Invalid symbol' in error_msg:
                return jsonify({
                    "error": f"Geçersiz sembol: {symbol}",
                    "detail": "Bu sembol Binance'de bulunamadı. Lütfen doğru sembol adını girin (örn: BTCUSDT)"
                }), 400
            
            return jsonify({
                "error": error_msg,
                "code": error_code,
                "symbol": symbol
            }), klines_response.status_code
        
        klines_data = klines_response.json()
        
        # Veri kontrolü
        if not klines_data or len(klines_data) == 0:
            print(f"⚠️ Klines verisi boş: {symbol}")
            return jsonify({
                "error": f"{symbol} için veri bulunamadı",
                "detail": "Bu sembol için hiç işlem verisi yok"
            }), 404
        
        # COMPACT MODE: Sadece gerekli alanları gönder (bandwidth %50 azalır)
        if compact:
            # Sadece: [timestamp, open, high, low, close, volume]
            compact_data = [[k[0], k[1], k[2], k[3], k[4], k[5]] for k in klines_data]
            return jsonify(compact_data)
        
        return jsonify(klines_data)
        
    except requests.exceptions.Timeout:
        print(f"⏱️ Timeout: {symbol}")
        return jsonify({"error": "İstek zaman aşımına uğradı", "symbol": symbol}), 408
    except requests.exceptions.RequestException as e:
        print(f"🌐 Network hatası: {symbol} - {e}")
        return jsonify({"error": "Bağlantı hatası", "detail": str(e)}), 503
    except Exception as e:
        print(f"💥 Beklenmeyen hata: {symbol} - {e}")
        import traceback
        traceback.print_exc()
        return jsonify({"error": "Sunucu hatası", "detail": str(e)}), 500

@app.route('/api/server_time', methods=['GET'])
def api_server_time():
    """Binance server time'ı döndürür (senkronizasyon için)"""
    try:
        time_url = "https://api.binance.com/api/v3/time"
        response = requests.get(time_url, timeout=5)
        response.raise_for_status()
        return jsonify(response.json())
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route('/api/validate_symbol', methods=['GET'])
def validate_symbol():
    """Sembolün Binance'de var olup olmadığını kontrol et"""
    symbol = request.args.get('symbol', '').upper()
    
    if not symbol:
        return jsonify({"valid": False, "error": "Sembol belirtilmedi"}), 400
    
    try:
        # exchangeInfo'dan kontrol et
        exchange_url = f"https://api.binance.com/api/v3/exchangeInfo?symbol={symbol}"
        response = requests.get(exchange_url, timeout=5)
        
        if response.status_code == 200:
            data = response.json()
            symbols = data.get('symbols', [])
            
            if symbols and len(symbols) > 0:
                symbol_info = symbols[0]
                return jsonify({
                    "valid": True,
                    "symbol": symbol_info['symbol'],
                    "status": symbol_info['status'],
                    "baseAsset": symbol_info['baseAsset'],
                    "quoteAsset": symbol_info['quoteAsset']
                })
            else:
                return jsonify({
                    "valid": False,
                    "error": f"{symbol} Binance'de bulunamadı"
                }), 404
        else:
            error_data = response.json() if response.text else {}
            return jsonify({
                "valid": False,
                "error": error_data.get('msg', 'Sembol bulunamadı')
            }), response.status_code
            
    except Exception as e:
        print(f"💥 Validate symbol hatası: {symbol} - {e}")
        return jsonify({"valid": False, "error": str(e)}), 500

def calculate_rsi(prices, period=14):
    """RSI hesaplama fonksiyonu"""
    if len(prices) < period + 1:
        return 0
    
    # Fiyat değişimlerini hesapla
    deltas = [prices[i] - prices[i-1] for i in range(1, len(prices))]
    
    # Kazanç ve kayıpları ayır
    gains = [delta if delta > 0 else 0 for delta in deltas]
    losses = [-delta if delta < 0 else 0 for delta in deltas]
    
    # İlk period için ortalama kazanç ve kayıp
    avg_gain = sum(gains[:period]) / period
    avg_loss = sum(losses[:period]) / period
    
    # RSI hesaplaması
    if avg_loss == 0:
        return 100
    
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    
    return rsi

def convert_to_heikin_ashi(candles):
    """Convert regular OHLC data to Heikin Ashi format"""
    if not candles or len(candles) == 0:
        return []
    
    ha_candles = []
    
    for i, candle in enumerate(candles):
        open_price = float(candle.get('open', 0))
        high_price = float(candle.get('high', 0))
        low_price = float(candle.get('low', 0))
        close_price = float(candle.get('close', 0))
        timestamp = candle.get('timestamp', 0)
        
        # Calculate Heikin Ashi values
        ha_close = (open_price + high_price + low_price + close_price) / 4
        
        if i == 0:
            # First candle: ha_open = (open + close) / 2
            ha_open = (open_price + close_price) / 2
        else:
            # Subsequent candles: ha_open = (previous_ha_open + previous_ha_close) / 2
            prev_ha_open = ha_candles[i-1]['ha_open']
            prev_ha_close = ha_candles[i-1]['ha_close']
            ha_open = (prev_ha_open + prev_ha_close) / 2
        
        # ha_high = max(high, ha_open, ha_close)
        ha_high = max(high_price, ha_open, ha_close)
        
        # ha_low = min(low, ha_open, ha_close)
        ha_low = min(low_price, ha_open, ha_close)
        
        ha_candle = {
            'ha_open': ha_open,
            'ha_high': ha_high,
            'ha_low': ha_low,
            'ha_close': ha_close,
            'timestamp': timestamp
        }
        
        ha_candles.append(ha_candle)
    
    return ha_candles

@app.route('/api/ticker', methods=['GET'])
def get_ticker():
    """Tek bir sembol için 24 saatlik ticker bilgisi"""
    symbol = request.args.get('symbol', 'BTCUSDT')
    
    try:
        ticker_url = f"https://api.binance.com/api/v3/ticker/24hr?symbol={symbol}"
        response = requests.get(ticker_url, timeout=5)
        
        # Binance API hata kontrolü
        if response.status_code != 200:
            error_data = response.json() if response.text else {}
            error_msg = error_data.get('msg', 'Bilinmeyen hata')
            error_code = error_data.get('code', response.status_code)
            
            print(f"❌ Ticker API Hatası: {symbol} - Code: {error_code} - Msg: {error_msg}")
            
            # Özel hata mesajları
            if error_code == -1121 or 'Invalid symbol' in error_msg:
                return jsonify({
                    "error": f"Geçersiz sembol: {symbol}",
                    "detail": "Bu sembol Binance'de bulunamadı"
                }), 400
            
            return jsonify({
                "error": error_msg,
                "code": error_code,
                "symbol": symbol
            }), response.status_code
        
        ticker_data = response.json()
        
        # Veri kontrolü
        if not ticker_data:
            print(f"⚠️ Ticker verisi boş: {symbol}")
            return jsonify({
                "error": f"{symbol} için ticker verisi bulunamadı"
            }), 404
        
        return jsonify(ticker_data)
        
    except requests.exceptions.Timeout:
        print(f"⏱️ Ticker Timeout: {symbol}")
        return jsonify({"error": "İstek zaman aşımına uğradı", "symbol": symbol}), 408
    except requests.exceptions.RequestException as e:
        print(f"🌐 Ticker Network hatası: {symbol} - {e}")
        return jsonify({"error": "Bağlantı hatası", "detail": str(e)}), 503
    except Exception as e:
        print(f"💥 Ticker beklenmeyen hata: {symbol} - {e}")
        import traceback
        traceback.print_exc()
        return jsonify({'error': 'Sunucu hatası', 'detail': str(e)}), 500

@app.route('/api/heikin_ashi', methods=['POST'])
def convert_heikin_ashi():
    """Convert OHLC data to Heikin Ashi format"""
    try:
        data = request.get_json()
        candles = data.get('candles', [])
        
        if not candles:
            return jsonify({'error': 'No candles data provided'}), 400
        
        # Convert to Heikin Ashi
        ha_candles = convert_to_heikin_ashi(candles)
        
        return jsonify({
            'success': True,
            'heikin_ashi': ha_candles,
            'count': len(ha_candles)
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/watchlist', methods=['GET'])
def get_watchlist():
    """İzleme listesindeki tüm sembollerin fiyatlarını getirir - OPTIMIZE EDİLDİ"""
    try:
        print("[INFO] Watchlist API cagrildi")
        
        # Varsayılan izleme listesi
        watchlist = {
            'CRYPTO': [
                'BTCUSDT', 'ETHUSDT', 'BNBUSDT', 'SOLUSDT', 'XRPUSDT',
                'ADAUSDT', 'DOGEUSDT', 'DOTUSDT', 'MATICUSDT', 'LTCUSDT',
                'AVAXUSDT', 'LINKUSDT', 'UNIUSDT', 'ATOMUSDT', 'ETCUSDT'
            ],
            'FOREX': [
                'EURUSDT', 'GBPUSDT', 'AUDUSDT'
            ],
            'PAIRS': [
                'ETHBTC', 'BNBBTC', 'ADABTC'
            ]
        }
        
        # Tüm sembolleri topla
        all_symbols = []
        for symbols in watchlist.values():
            all_symbols.extend(symbols)
        
        # TEK BİR API ÇAĞRISI ile tüm ticker verilerini al
        ticker_url = "https://api.binance.com/api/v3/ticker/24hr"
        ticker_response = requests.get(ticker_url, timeout=10)
        
        if ticker_response.status_code != 200:
            print(f"[ERROR] Ticker API hatasi: HTTP {ticker_response.status_code}")
            return jsonify({'error': 'Binance API hatası'}), 500
        
        all_tickers = ticker_response.json()
        
        # Sembolleri dictionary'e dönüştür (hızlı arama için)
        ticker_dict = {ticker['symbol']: ticker for ticker in all_tickers}
        
        result = {}
        total_symbols = 0
        successful = 0
        
        # Her kategori için verileri filtrele
        for category, symbols in watchlist.items():
            category_data = []
            
            for symbol in symbols:
                total_symbols += 1
                if symbol in ticker_dict:
                    ticker_data = ticker_dict[symbol]
                    category_data.append({
                        'symbol': symbol,
                        'price': float(ticker_data.get('lastPrice', 0)),
                        'change': float(ticker_data.get('priceChange', 0)),
                        'changePercent': float(ticker_data.get('priceChangePercent', 0)),
                        'high': float(ticker_data.get('highPrice', 0)),
                        'low': float(ticker_data.get('lowPrice', 0)),
                        'volume': float(ticker_data.get('volume', 0))
                    })
                    successful += 1
                else:
                    print(f"[WARNING] {symbol}: Bulunamadi")
            
            if category_data:
                result[category] = category_data
        
        print(f"[SUCCESS] Watchlist tamamlandi: {successful}/{total_symbols} basarili (TEK API cagrisi)")
        return jsonify(result)
        
    except Exception as e:
        print(f"[ERROR] Watchlist hatasi: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/balance/debug', methods=['GET'])
def debug_balance_api():
    """Bakiye API debug endpoint - imzalama ve key kontrolü"""
    try:
        from config import BINANCE_API_KEY, BINANCE_API_SECRET
        
        debug_info = {
            'api_key_exists': bool(BINANCE_API_KEY),
            'api_key_length': len(BINANCE_API_KEY) if BINANCE_API_KEY else 0,
            'api_key_preview': BINANCE_API_KEY[:10] + '...' if BINANCE_API_KEY else 'YOK',
            'secret_exists': bool(BINANCE_API_SECRET),
            'secret_length': len(BINANCE_API_SECRET) if BINANCE_API_SECRET else 0,
            'secret_format': 'PEM (RSA)' if BINANCE_API_SECRET and '-----BEGIN' in BINANCE_API_SECRET else 'HMAC' if BINANCE_API_SECRET else 'YOK',
            'secret_preview': BINANCE_API_SECRET[:50] + '...' if BINANCE_API_SECRET else 'YOK'
        }
        
        # Test imzalama
        test_params = {'timestamp': 1234567890, 'test': 'value'}
        signature = sign_request(test_params, BINANCE_API_SECRET)
        debug_info['test_signature_success'] = bool(signature)
        debug_info['test_signature_length'] = len(signature) if signature else 0
        
        return jsonify(debug_info)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/balance', methods=['GET'])
def get_balance_api():
    """Binance hesap bakiyesini API'den çeker - GERÇEK API KULLANIR"""
    try:
        print("\n" + "="*60)
        print("[INFO] Bakiye API çağrıldı")
        print("="*60)
        
        # Gerçek API'den bakiye al
        balance_result = get_account_balance()
        
        if balance_result['success']:
            print(f"[SUCCESS] Bakiye başarıyla alındı: {len(balance_result['balances'])} varlık")
            print("="*60 + "\n")
            return jsonify({
                'success': True,
                'balances': balance_result['balances']
            })
        else:
            error_msg = balance_result.get('error', 'Bilinmeyen hata')
            print(f"[ERROR] Bakiye alınamadı: {error_msg}")
            print("="*60 + "\n")
            return jsonify({
                'success': False,
                'error': f'Bakiye alınamadı: {error_msg}'
            }), 400
            
    except Exception as e:
        print(f"[ERROR] Bakiye API hatası: {e}")
        print("="*60 + "\n")
        import traceback
        traceback.print_exc()
        return jsonify({
            'success': False,
            'error': f'Beklenmeyen hata: {str(e)}'
        }), 500

@app.route('/api/min_notional', methods=['GET'])
def get_min_notional_api():
    """
    Sembollerin minimum notional değerlerini döndürür
    
    Query params:
        symbol: Tek bir sembol (opsiyonel) - örn: BTCUSDT
        
    Returns:
        {
            'success': True,
            'min_notionals': {
                'BTCUSDT': 10.0,
                'DOGEUSDT': 5.0,
                'AVAXUSDT': 1.0,
                ...
            }
        }
    """
    try:
        symbol = request.args.get('symbol')
        
        if symbol:
            # Tek sembol için
            min_notional = get_symbol_min_notional(symbol)
            return jsonify({
                'success': True,
                'symbol': symbol,
                'min_notional': min_notional
            })
        else:
            # Tüm semboller için
            min_notionals = get_all_symbols_min_notional()
            return jsonify({
                'success': True,
                'min_notionals': min_notionals,
                'count': len(min_notionals)
            })
            
    except Exception as e:
        print(f"[ERROR] Min notional API hatası: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500


# =============================================================================
# HEALTH TICK FONKSİYONLARI
# =============================================================================

 

 

# =============================================================================
# FLASK APP BAŞLATMA
# =============================================================================

if __name__ == '__main__':
    print("🚀 Flask uygulaması başlatılıyor...")
    print("📡 Port: 5000")
    print("🌐 URL: http://localhost:5000")
    
    # Flask app'i başlat
    app.run(
        host='0.0.0.0',
        port=5000,
        debug=True,
        use_reloader=True
    )