main.py

#!/usr/bin/env python3
"""
SUPERTRADEX using SYNTHRON CRYPTO TRADER codebase
"""
import sys
import asyncio
import pandas as pd
import time
import logging
import os
import json
from pathlib import Path
from datetime import datetime, timezone
import signal
import httpx
from dotenv import load_dotenv, dotenv_values
import io
from solana.rpc.async_api import AsyncClient
from logging.handlers import RotatingFileHandler
from typing import List, Optional, Type, Dict, Any
import aiohttp
import queue
import threading
from config.settings import EncryptionSettings
from sqlalchemy import select, desc, asc
from fastapi import FastAPI
import json
import websockets
import threading
from typing import Set
from dataclasses import dataclass, field

class RealtimeLogHandler(logging.Handler):
    """Custom log handler that broadcasts log entries to WebSocket clients"""

    def __init__(self, realtime_manager):
        super().__init__()
        self.realtime_manager = realtime_manager
        self.log_queue = queue.Queue()
        self.broadcast_thread = None
        self.start_broadcast_thread()

    def start_broadcast_thread(self):
        """Start background thread to broadcast queued log entries"""
        def broadcast_worker():
            while True:
                try:
                    log_entry = self.log_queue.get(timeout=1)
                    if log_entry:
                        # Broadcast asynchronously
                        asyncio.create_task(self.realtime_manager.broadcast_log_update(log_entry))
                    self.log_queue.task_done()
                except queue.Empty:
                    continue
                except Exception as e:
                    logger.error(f"Error in log broadcast thread: {e}")

        self.broadcast_thread = threading.Thread(target=broadcast_worker, daemon=True)
        self.broadcast_thread.start()

    def emit(self, record):
        """Emit a log record - queue it for broadcasting"""
        try:
            # Format the log entry
            log_entry = {
                "timestamp": time.time(),
                "level": record.levelname,
                "message": self.format(record),
                "logger": record.name
            }

            # Queue for broadcasting (non-blocking)
            try:
                self.log_queue.put_nowait(log_entry)
            except queue.Full:
                # If queue is full, drop the oldest entry
                try:
                    self.log_queue.get_nowait()
                    self.log_queue.put_nowait(log_entry)
                except queue.Empty:
                    pass

        except Exception:
            self.handleError(record)

@dataclass
class RealtimeEventManager:
    """Manages real-time event broadcasting to web clients"""

    connected_clients: Set[websockets.WebSocketServerProtocol] = field(default_factory=set)
    websocket_server = None
    server_thread = None

    async def start_websocket_server(self, host: str = "127.0.0.1", port: int = 8765):
        """Start the WebSocket server for real-time updates"""
        logger.info(f"🚀 Starting real-time WebSocket server on {host}:{port}")

        async def websocket_handler(websocket, path):
            """Handle new WebSocket connections"""
            self.connected_clients.add(websocket)
            logger.info(f"📡 WebSocket client connected. Total clients: {len(self.connected_clients)}")

            try:
                await websocket.send(json.dumps({
                    "event": "connected",
                    "type": "system",
                    "data": {"message": "Connected to SuperTradeX real-time updates"},
                    "timestamp": time.time()
                }))

                # Keep connection alive
                async for message in websocket:
                    # Handle client messages if needed
                    try:
                        data = json.loads(message)
                        if data.get("type") == "ping":
                            await websocket.send(json.dumps({
                                "event": "pong",
                                "type": "system",
                                "timestamp": time.time()
                            }))
                    except json.JSONDecodeError:
                        pass

            except websockets.exceptions.ConnectionClosed:
                pass
            finally:
                self.connected_clients.discard(websocket)
                logger.info(f"📡 WebSocket client disconnected. Total clients: {len(self.connected_clients)}")

        # Start server in background thread
        async def run_server():
            self.websocket_server = await websockets.serve(
                websocket_handler,
                host,
                port,
                ping_interval=20,
                ping_timeout=10
            )
            logger.info(f"✅ WebSocket server started on ws://{host}:{port}")
            await self.websocket_server.wait_closed()

        # Run server in thread to avoid blocking
        def run_in_thread():
            asyncio.new_event_loop().run_until_complete(run_server())

        self.server_thread = threading.Thread(target=run_in_thread, daemon=True)
        self.server_thread.start()

    async def stop_websocket_server(self):
        """Stop the WebSocket server"""
        if self.websocket_server:
            self.websocket_server.close()
            await self.websocket_server.wait_closed()
            logger.info("🛑 WebSocket server stopped")

    async def broadcast_event(self, event_type: str, event_data: dict):
        """Broadcast an event to all connected WebSocket clients"""
        if not self.connected_clients:
            return

        message = {
            "event": event_type,
            "type": "realtime_update",
            "data": event_data,
            "timestamp": time.time()
        }

        message_str = json.dumps(message)
        disconnected_clients = set()

        for client in self.connected_clients.copy():
            try:
                await client.send(message_str)
            except websockets.exceptions.ConnectionClosed:
                disconnected_clients.add(client)
            except Exception as e:
                logger.error(f"Error broadcasting to WebSocket client: {e}")
                disconnected_clients.add(client)

        # Remove disconnected clients
        for client in disconnected_clients:
            self.connected_clients.discard(client)

        if self.connected_clients:
            logger.debug(f"📡 Broadcast '{event_type}' to {len(self.connected_clients)} clients")

    async def broadcast_token_update(self, token_data: dict):
        """Broadcast token price/monitoring updates"""
        await self.broadcast_event("token_update", token_data)

    async def broadcast_trade_update(self, trade_data: dict):
        """Broadcast trade execution updates"""
        await self.broadcast_event("trade_update", trade_data)

    async def broadcast_log_update(self, log_entry: dict):
        """Broadcast new log entries"""
        await self.broadcast_event("log_update", log_entry)

    async def broadcast_system_status(self, status_data: dict):
        """Broadcast system status updates"""
        await self.broadcast_event("system_status", status_data)

    async def broadcast_paper_trading_update(self, paper_data: dict):
        """Broadcast paper trading updates"""
        await self.broadcast_event("paper_trading", paper_data)

# Add project root to sys.path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

# --- Centralized Imports (Grouped) ---
# Configuration
from config import Settings
from config.logging_config import LoggingConfig
from config.solana_config import SolanaConfig
from config.dexscreener_api import DexScreenerAPI
from config.thresholds import Thresholds
from config.filters_config import FiltersConfig

# Utilities
from utils.encryption import decrypt_env_file, test_encryption, get_encryption_password
from utils.circuit_breaker import CircuitBreaker
from utils.proxy_manager import ProxyManager
from utils.helpers import ensure_directory_exists, setup_output_dirs
from utils import get_logger, get_git_commit_hash
from utils.logger import get_logger

# Data Components
# Import DataPackage first
from data import DataPackage
from data.market_data import MarketData
# Then import individual components needed for external initialization
from data.token_database import TokenDatabase, Token
from data.price_monitor import PriceMonitor
from data.monitoring import VolumeMonitor, Monitoring # Import Monitoring here if needed externally
from data.blockchain_listener import BlockchainListener  # Add import for BlockchainListener
# MonitoringSimple is no longer needed, we're using MarketData instead
# from data.monitoring_simple import MonitoringSimple  # Import our simplified monitoring class
# No need to import components initialized *inside* DataPackage unless used directly elsewhere
# Import TokenMetrics
from data.token_metrics import TokenMetrics # Added import
from data.platform_tracker import PlatformTracker # Added import for PlatformTracker
from data.data_processing import DataProcessing
from data.data_fetcher import DataFetcher
from data.delta_calculator import DeltaCalculator
from data.indicators import Indicators # Added this import
from data.token_scanner import TokenScanner # Added import for TokenScanner

# Filter Components
from filters.whitelist import Whitelist
from filters.blacklist import Blacklist # Added import
from filters import FilterManager # Import manager
# Import components needed for FilterManager initialization
from filters.twitter_check import TwitterCheck
# No need to import individual filters if only used via FilterManager config

# API Clients (Specific Examples)
from config.rugcheck_api import RugcheckAPI
from filters.solsniffer_api import SolsnifferAPI
from data.solanatracker_api import SolanaTrackerAPI

# Execution Components
from execution.trade_queue import TradeQueue
from execution.order_manager import OrderManager
from execution.transaction_tracker import TransactionTracker
from execution.trade_scheduler import TradeScheduler, TradeTrigger, TriggerType # Added Trigger imports

# Strategy Components
from strategies.entry_exit import EntryExitStrategy
from strategies.risk_management import RiskManagement, TokenRiskMonitor
from strategies.position_management import PositionManagement
from strategies.alert_system import AlertSystem
from strategies.paper_trading import PaperTrading
# Add StrategySelector import
from strategies.strategy_selector import StrategySelector
from strategies import StrategyEvaluator # ADDED - to import the correct one

# Wallet Components
from wallet.wallet_manager import WalletManager
from wallet.balance_checker import BalanceChecker
from wallet.trade_validator import TradeValidator

# Import additional components needed for focused monitoring
from strategies.paper_trading import PaperTrading
from data.blockchain_listener import BlockchainListener
from data.hybrid_monitoring_manager import HybridMonitoringManager, TokenPriority
from data.focused_monitoring import FocusedMonitoringManager, FocusedTokenData

# FocusedTokenData and FocusedMonitoringManager have been moved to data.focused_monitoring

# Define helper function for updating env vars BEFORE it's called
def update_dotenv_vars(env_vars: dict, override: bool = False) -> None:
    """Update os.environ with the given environment variables."""
    # Check if the logger is already configured, otherwise print
    global logger # Access the globally defined logger
    log_func = logger.debug if logger and logger.hasHandlers() else print

    updated_count = 0
    skipped_count = 0
    for key, value in env_vars.items():
        if value is None: # Skip if value is None
             log_func(f"Skipping None value for env var: {key}")
             skipped_count += 1
             continue

        value_str = str(value) # Ensure value is string

        if override or key not in os.environ:
            os.environ[key] = value_str
            # Mask sensitive keys before logging
            log_value = value_str[:3] + '...' + value_str[-3:] if len(value_str) > 6 and ('KEY' in key.upper() or 'SECRET' in key.upper() or 'PASSWORD' in key.upper()) else value_str
            log_func(f"Set env var: {key}={log_value}")
            updated_count += 1
        else:
            log_func(f"Skipped env var (already exists, override=False): {key}")
            skipped_count += 1
    log_func(f"Env var update: {updated_count} set, {skipped_count} skipped.")

# Initialize logger early for startup messages
logger = logging.getLogger(__name__)

# --- Constants ---
ENV_DIR = project_root / "config"
ENV_PLAIN_PATH = ENV_DIR / ".env"
ENV_ENCRYPTED_PATH = ENV_DIR / ".env.encrypted"

# Maximum runtime in seconds (e.g., 24 hours). None for indefinite.
MAX_RUNTIME_SECONDS = None

# --- Environment Variable Loading Logic ---
print("--- Loading Environment Variables --- ")
variables_loaded_count = 0

# 1. Try getting encryption password
password = None

# Load the key-file path from our config layer
key_settings = EncryptionSettings()
key_file_to_use = key_settings.ENCRYPTION_KEY_PATH
print(f"INFO: Using key filename for password retrieval: {key_file_to_use}")
try:
    password = get_encryption_password()
    if password:
        print("INFO: Successfully retrieved encryption password from stored key.")
    else:
        # Fallback to environment variable if stored password retrieval failed
        password = os.getenv("ENCRYPTION_PASSWORD")
        if password:
            print("INFO: Using encryption password from ENCRYPTION_PASSWORD environment variable.")
        else:
            print("INFO: No stored or environment encryption password found.")
except Exception as e:
    print(f"ERROR: Could not retrieve encryption password: {e}")

# 2. Skip encrypted file for now (using plain .env file)
if ENV_ENCRYPTED_PATH.exists():
    print(f"INFO: Skipping encrypted environment file: {ENV_ENCRYPTED_PATH} (using plain .env)")
else:
    print(f"INFO: Encrypted environment file not found: {ENV_ENCRYPTED_PATH}")

# 3. Load plain .env file (overrides anything loaded from encrypted file)
if ENV_PLAIN_PATH.exists():
    print(f"INFO: Loading plain environment file (with override): {ENV_PLAIN_PATH}")
    try:
        loaded_plain_count = load_dotenv(dotenv_path=ENV_PLAIN_PATH, override=True)
        if loaded_plain_count:
            # Only increment count if encrypted wasn't loaded
            if variables_loaded_count == 0:
                variables_loaded_count += 1
                print(f"INFO: Successfully loaded/overridden variables from plain file: {ENV_PLAIN_PATH}")
            else:
                 print(f"INFO: Plain file {ENV_PLAIN_PATH} loaded, but encrypted vars took precedence (override=True still applies).")
        else:
            print(f"WARNING: Plain environment file {ENV_PLAIN_PATH} exists but failed to load/override any variables.")
    except Exception as e:
        print(f"ERROR: Failed loading plain env file {ENV_PLAIN_PATH}: {e}")
else:
    print(f"INFO: Plain environment file not found: {ENV_PLAIN_PATH}")

if variables_loaded_count == 0:
    print("WARNING: No environment variables loaded from config/.env or config/.env.encrypted. Relying on system environment.")
print("--- Environment Variable Loading Complete --- ")


# --- Settings and Logging Setup (Initialize AFTER loading ALL env vars) ---
try:
    settings = Settings()
    LoggingConfig.setup_logging(settings=settings)
    logger = logging.getLogger(__name__) # Re-get logger after setup
    
    # Setup specialized loggers for prices and trades
    from config.logging_config import setup_specialized_loggers
    price_logger, trade_logger = setup_specialized_loggers()
    logger.info("📊 Specialized loggers initialized: prices.log and trades.log")

    # Add real-time log handler to the root logger (only if realtime_manager is available)
    if 'realtime_manager' in locals() and realtime_manager:
        realtime_log_handler = RealtimeLogHandler(realtime_manager)
        realtime_log_handler.setLevel(logging.INFO)
        realtime_log_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
        logging.getLogger().addHandler(realtime_log_handler)
        logger.info("🔄 Real-time log broadcasting enabled")
    # --- Explicitly set websockets logger level to INFO ---
    websockets_logger = logging.getLogger('websockets')
    websockets_logger.setLevel(logging.INFO)
    # Optional: Ensure handlers also respect this level if they have their own level set higher
    # for handler in websockets_logger.handlers:
    #     handler.setLevel(logging.INFO)
    # # Propagate setting to root handlers if no specific handlers are attached 
    # if not websockets_logger.handlers:
    #    for handler in logging.getLogger().handlers:
    #        # Be careful not to lower the level of handlers meant for higher levels (e.g., ERROR file handler)
    #        # This part might be unnecessary if root handlers are already at INFO or DEBUG
    #        pass # Usually inheriting from root is sufficient
    logger.info("Websockets logger level forced to INFO.") # Add log message
    # -----------------------------------------------------
    # --- REMOVED Explicit TokenScanner Debug Setting --- ## REMOVED ##
    # token_scanner_logger = logging.getLogger('data.token_scanner')
    # token_scanner_logger.setLevel(logging.DEBUG)
    # --- Added Debug Setting for MarketData --- #
    logging.getLogger('data.market_data').setLevel(logging.DEBUG)
    logger.info("Logging configured successfully.")
    logger.info("Settings loaded and Logging configured.")
except ValueError as e:
    initial_logger = logging.getLogger("startup_error")
    initial_logger.error(f"CRITICAL ERROR: Missing required environment variable: {e}. Check .env files. Exiting.")
    print("--- Loaded Environment Variables (at time of error) ---")
    debug_vars = {k: (v[:3] + '...' + v[-3:] if isinstance(v, str) and len(v)>6 and ('KEY' in k or 'SECRET' in k or 'PASSWORD' in k) else v) for k, v in os.environ.items()}
    print(json.dumps(debug_vars, indent=2))
    print("--- End Loaded Environment Variables --- ")
    sys.exit(1)
except Exception as e:
    initial_logger = logging.getLogger("startup_error")
    initial_logger.error(f"CRITICAL ERROR during Settings initialization: {e}. Exiting.", exc_info=True)
    sys.exit(1)


# --- Helper Function for Graceful Shutdown ---
async def close_all_components(components_dict: dict):
    """Safely closes components listed in the dictionary."""
    logger.info("--- Closing All Components ---")
    # Close in reverse order of initialization or based on dependencies
    
    # Close StrategyEvaluator first if it depends on MarketData, DB etc.
    strategy_evaluator = components_dict.get("strategy_evaluator")
    if strategy_evaluator and hasattr(strategy_evaluator, 'close') and callable(getattr(strategy_evaluator, 'close')):
        try:
            logger.info("Closing StrategyEvaluator...")
            await strategy_evaluator.close()
            logger.info("StrategyEvaluator closed.")
        except Exception as e:
            logger.error(f"Error closing StrategyEvaluator: {e}", exc_info=True)

    # Close TradeExecutor
    trade_executor = components_dict.get("trade_executor")
    if trade_executor and hasattr(trade_executor, 'close') and callable(getattr(trade_executor, 'close')):
        try:
            logger.info("Closing TradeExecutor...")
            await trade_executor.close() # Assuming it has an async close
            logger.info("TradeExecutor closed.")
        except Exception as e:
            logger.error(f"Error closing TradeExecutor: {e}", exc_info=True)

    # Close Realtime Manager
    realtime_manager = components_dict.get("realtime_manager")
    if realtime_manager and hasattr(realtime_manager, 'stop_websocket_server') and callable(getattr(realtime_manager, 'stop_websocket_server')):
        try:
            logger.info("Stopping RealtimeEventManager...")
            await realtime_manager.stop_websocket_server()
            logger.info("RealtimeEventManager stopped.")
        except Exception as e:
            logger.error(f"Error stopping RealtimeEventManager: {e}", exc_info=True)

    # Close TokenScanner
    token_scanner = components_dict.get("token_scanner")
    if token_scanner and hasattr(token_scanner, 'close') and callable(getattr(token_scanner, 'close')):
        try:
            logger.info("Closing TokenScanner...")
            await token_scanner.close()
            logger.info("TokenScanner closed.")
        except Exception as e:
            logger.error(f"Error closing TokenScanner: {e}", exc_info=True)

    # Close MarketData
    market_data = components_dict.get("market_data")
    if market_data and hasattr(market_data, 'close') and callable(getattr(market_data, 'close')):
        try:
            logger.info("Closing MarketData...")
            await market_data.close()
            logger.info("MarketData closed.")
        except Exception as e:
            logger.error(f"Error closing MarketData: {e}", exc_info=True)
            
    # Close WalletManager
    wallet_manager = components_dict.get("wallet_manager")
    if wallet_manager and hasattr(wallet_manager, 'close') and callable(getattr(wallet_manager, 'close')):
        try:
            logger.info("Closing WalletManager...")
            await wallet_manager.close()
            logger.info("WalletManager closed.")
        except Exception as e:
            logger.error(f"Error closing WalletManager: {e}", exc_info=True)

    # Close Hybrid Monitoring Manager
    hybrid_monitoring = components_dict.get("hybrid_monitoring")
    if hybrid_monitoring and hasattr(hybrid_monitoring, 'close') and callable(getattr(hybrid_monitoring, 'close')):
        try:
            logger.info("Closing HybridMonitoringManager...")
            await hybrid_monitoring.close()
            logger.info("HybridMonitoringManager closed.")
        except Exception as e:
            logger.error(f"Error closing HybridMonitoringManager: {e}", exc_info=True)
    
    # Close Enhanced PumpSwap Parser Stream
    helius_pump_parser = components_dict.get("helius_pump_parser")
    if helius_pump_parser and hasattr(helius_pump_parser, 'stop_helius_pump_stream') and callable(getattr(helius_pump_parser, 'stop_helius_pump_stream')):
        try:
            logger.info("Stopping Helius Pump AMM stream...")
            await helius_pump_parser.stop_helius_pump_stream()
            logger.info("Helius Pump AMM stream stopped.")
        except Exception as e:
            logger.error(f"Error stopping Helius Pump AMM stream: {e}", exc_info=True)

    # Close Blockchain Listener
    blockchain_listener = components_dict.get("blockchain_listener")
    if blockchain_listener and hasattr(blockchain_listener, 'close') and callable(getattr(blockchain_listener, 'close')):
        try:
            logger.info("Closing BlockchainListener...")
            await blockchain_listener.close()
            logger.info("BlockchainListener closed.")
        except Exception as e:
            logger.error(f"Error closing BlockchainListener: {e}", exc_info=True)

    # Close Database
    db = components_dict.get("db")
    if db and hasattr(db, 'close') and callable(getattr(db, 'close')):
        try:
            logger.info("Closing TokenDatabase...")
            await db.close()
            logger.info("TokenDatabase closed.")
        except Exception as e:
            logger.error(f"Error closing TokenDatabase: {e}", exc_info=True)

    # Close HTTP Client
    http_client = components_dict.get("http_client")
    if http_client and hasattr(http_client, 'aclose') and callable(getattr(http_client, 'aclose')):
        try:
            logger.info("Closing HTTPX Client...")
            await http_client.aclose()
            logger.info("HTTPX Client closed.")
        except Exception as e:
            logger.error(f"Error closing HTTPX Client: {e}", exc_info=True)
            
    # Close Solana Client
    solana_client = components_dict.get("solana_client")
    if solana_client and hasattr(solana_client, 'close') and callable(getattr(solana_client, 'close')):
        try:
            logger.info("Closing Solana Client...")
            await solana_client.close() # Ensure this is the correct close method
            logger.info("Solana Client closed.")
        except Exception as e:
            logger.error(f"Error closing Solana Client: {e}", exc_info=True)
            
    # Close SolanaTrackerAPI
    solana_tracker_api = components_dict.get("solana_tracker_api")
    if solana_tracker_api and hasattr(solana_tracker_api, 'close') and callable(getattr(solana_tracker_api, 'close')):
        try:
            logger.info("Closing SolanaTrackerAPI...")
            await solana_tracker_api.close()
            logger.info("SolanaTrackerAPI closed.")
        except Exception as e:
            logger.error(f"Error closing SolanaTrackerAPI: {e}", exc_info=True)

    # Close PlatformTracker
    platform_tracker = components_dict.get("platform_tracker")
    if platform_tracker and hasattr(platform_tracker, 'close') and callable(getattr(platform_tracker, 'close')):
        try:
            logger.info("Closing PlatformTracker...")
            await platform_tracker.close()
            logger.info("PlatformTracker closed.")
        except Exception as e:
            logger.error(f"Error closing PlatformTracker: {e}", exc_info=True)

    # Example for other components if they have close methods
    # filter_manager = components_dict.get("filter_manager")
    # if filter_manager and hasattr(filter_manager, 'close'):
    # try:
    # logger.info("Closing FilterManager...")
    # await filter_manager.close()
    # logger.info("FilterManager closed.")
    # except Exception as e:
    # logger.error(f"Error closing FilterManager: {e}", exc_info=True)

    logger.info("--- All Components Closed ---")


async def signal_handler_async(shutdown_event: asyncio.Event, 
                               logger_instance: logging.Logger):
    """Coroutine to handle signals by setting the shutdown event."""
    if shutdown_event.is_set():
        logger_instance.info("signal_handler_async: Shutdown already in progress.")
        return

    logger_instance.info("signal_handler_async: Signal received, setting shutdown_event. Main `finally` block will handle component cleanup and handler restoration.")
    
    # Clean up PID file
    pid_file = Path("supertradex.pid")
    try:
        if pid_file.exists():
            pid_file.unlink()
            logger_instance.info("PID file removed during shutdown")
    except Exception as e:
        logger_instance.warning(f"Could not remove PID file: {e}")
    
    shutdown_event.set()


# --- Unified Asynchronous Component Initialization Function ---
async def initialize_components(settings: Settings, realtime_manager=None) -> dict:
    """Initializes and returns all core application components."""
    logger.info("--- Initializing Core Components ---")
    start_time = time.time()
    
    # Initialize basic utilities
    proxy_manager = ProxyManager(settings.PROXY_FILE_PATH) if settings.USE_PROXIES else None
    if proxy_manager:
        logger.info(f"ProxyManager initialized. {len(proxy_manager.get_all_proxies())} proxies loaded.")

    # Setup HTTP client session (aiohttp or httpx based on preference)
    # Using httpx as an example, compatible with proxy_manager
    if proxy_manager:
        # If using proxies, get a proxy URL for the client to use
        proxy_url = proxy_manager.get_proxy_url()
        if proxy_url:
            transport = httpx.AsyncHTTPTransport(proxy_url=proxy_url)
            http_client = httpx.AsyncClient(transport=transport, timeout=settings.HTTP_TIMEOUT)
            logger.info(f"HTTPX AsyncClient initialized with proxy: {proxy_url}")
        else:
            http_client = httpx.AsyncClient(timeout=settings.HTTP_TIMEOUT)
            logger.info("HTTPX AsyncClient initialized without proxy (no valid proxies available)")
    else:
        http_client = httpx.AsyncClient(timeout=settings.HTTP_TIMEOUT)
        logger.info("HTTPX AsyncClient initialized without proxy manager")
    logger.info(f"HTTPX AsyncClient initialized. Timeout: {settings.HTTP_TIMEOUT}s")

    # Initialize Solana client
    solana_client = AsyncClient(settings.SOLANA_RPC_URL)
    logger.info(f"Solana AsyncClient initialized for endpoint: {settings.SOLANA_RPC_URL}")

    # --- Database Initialization ---
    db = await TokenDatabase.create(settings.DATABASE_FILE_PATH, settings)
    if not db:
        logger.critical("Failed to initialize TokenDatabase. Exiting.")
        raise RuntimeError("Failed to initialize TokenDatabase.")
    logger.info(f"TokenDatabase initialized with DB: {settings.DATABASE_FILE_PATH}")
    
    # --- Configuration Objects ---
    thresholds = Thresholds(settings=settings)
    logger.info("Thresholds initialized.")
    filters_config = FiltersConfig(settings=settings, thresholds=thresholds)
    logger.info("FiltersConfig initialized.")

    # --- Wallet Manager ---
    wallet_manager = WalletManager(settings=settings, solana_client=solana_client, db=db)
    await wallet_manager.initialize() # Initialize and load keypair
    logger.info("WalletManager initialized.")

    # Initialize shared HTTP and Solana clients
    # ... (http_client, solana_client, proxy_manager initialization) ...

    # Initialize main DexScreenerAPI client (SHARED INSTANCE)
    logger.info("Initializing main DexScreenerAPI client...")
    dexscreener_api = DexScreenerAPI(settings, proxy_manager=proxy_manager)
    if not await dexscreener_api.initialize():
        logger.warning("DexScreenerAPI initialization failed, but continuing system startup. Some features may be limited.")
        # Don't exit - allow the system to continue without DexScreener API
        # The API will retry connections when actually needed
    else:
        logger.info("Main DexScreenerAPI client initialized successfully.")

    # Initialize MarketData, pass the SHARED dexscreener_api
    logger.info("Initializing MarketData...")
    market_data = MarketData(settings, dexscreener_api=dexscreener_api, token_db=db, http_client=http_client, solana_client=solana_client)
    if not await market_data.initialize():
        logger.critical("Failed to initialize MarketData. Exiting.")
        # Perform necessary cleanup before exiting
        await dexscreener_api.close() # Close the shared instance
        if proxy_manager: await proxy_manager.close_session()
        if http_client: await http_client.aclose()
        if solana_client: await solana_client.close() # Changed to .close()
        if db: await db.close()
        return None
    logger.info("MarketData initialized successfully.")
    
    # Initialize other components like FilterManager, TokenMetrics, APIs...
    # (Existing code for FilterManager, TokenMetrics, RugcheckAPI, SolsnifferAPI, TwitterCheck)
    # ...

    # Initialize main DexScreenerAPI client (SHARED INSTANCE)
    # ... (dexscreener_api initialization) ...

    # Initialize MarketData, pass the SHARED dexscreener_api
    # ... (market_data initialization) ...

    # --- Initialize components needed by FilterManager and TokenScanner ---
    logger.info("Initializing API clients for FilterManager...")
    rugcheck_api = RugcheckAPI(settings=settings, proxy_manager=proxy_manager)
    logger.info("RugcheckAPI initialized.")
    # SolsnifferAPI only accepts settings
    solsniffer_api = SolsnifferAPI(settings=settings) 
    logger.info("SolsnifferAPI initialized.")
    # TwitterCheck accepts settings and thresholds
    twitter_check = TwitterCheck(settings=settings, thresholds=thresholds)
    await twitter_check.initialize()  # TwitterCheck has async initialize
    logger.info("TwitterCheck initialized.")

    logger.info("Initializing FilterManager...")
    filter_manager = FilterManager(
        settings=settings,
        thresholds=thresholds,
        filters_config=filters_config,
        db=db,
        http_client=http_client, 
        solana_client=solana_client, 
        price_monitor=market_data.price_monitor, # Get from MarketData
        rugcheck_api=rugcheck_api,
        solsniffer_api=solsniffer_api,
        twitter_check=twitter_check
    )
    logger.info("FilterManager initialized successfully.")

    logger.info("Initializing TokenMetrics...")
    # TokenMetrics needs many components that we haven't initialized yet
    # For now, let's skip TokenMetrics initialization and continue with other components
    # token_metrics = TokenMetrics(...)
    token_metrics = None  # Placeholder - will be initialized later
    logger.info("TokenMetrics initialization deferred (missing dependencies).") 
    # --- End FilterManager and TokenScanner dependencies ---

    # TokenScanner initialization will be moved after TokenMetrics is properly initialized
    token_scanner = None  # Placeholder - will be initialized later
    logger.info("TokenScanner initialization deferred until TokenMetrics is ready.")

    # Initialize PlatformTracker (after TokenScanner if it depends on it, or in parallel if not)
    logger.info("Initializing PlatformTracker...")
    # PlatformTracker expects: db, settings, thresholds, solana_client
    platform_tracker = PlatformTracker(db, settings, thresholds, solana_client)
    if not await platform_tracker.initialize():
        logger.critical("Failed to initialize PlatformTracker. Exiting.")
        # ... (full cleanup) ...
        return None
    logger.info("PlatformTracker initialized successfully.")

    # Skip DataPackage for now - it's causing TokenMetrics initialization issues
    # All necessary components are already initialized above
    logger.info("Skipping DataPackage initialization (not required for basic functionality).")
    data_package = None

    # Initialize trade queue

    # --- Execution Components (needed by StrategyComponents) ---
    balance_checker = BalanceChecker(
        solana_client=solana_client,
        wallet_pubkey=wallet_manager.get_public_key(),
        http_client=http_client,
        settings=settings
    )
    trade_validator = TradeValidator(balance_checker=balance_checker, settings=settings)
    order_manager = OrderManager(
        settings=settings,
        solana_client=solana_client,
        db=db,
        wallet_manager=wallet_manager,
        http_client=http_client,
        trade_validator=trade_validator,
        price_monitor=market_data.price_monitor # price_monitor comes from market_data
    )
    trade_queue = TradeQueue(order_manager=order_manager)
    # Initialize TransactionTracker here as it can be needed by other strategy components initialized shortly
    transaction_tracker = TransactionTracker(settings=settings, solana_client=solana_client, db=db)
    logger.info("Core execution components (BalanceChecker, TradeValidator, OrderManager, TradeQueue, TransactionTracker) initialized.")

    # --- Strategy Components ---
    # Initialize AlertSystem first as it's a dependency for RiskMgmt and PositionMgmt
    alert_system = AlertSystem() # AlertSystem initializes its own settings and does not take db/thresholds
    logger.info("AlertSystem initialized.")

    # Initialize Blacklist as it's needed by StrategySelector
    blacklist = Blacklist(db=db) # Blacklist only takes db
    logger.info("Blacklist initialized.")

    # Initialize RiskManagement
    risk_management = RiskManagement(
        settings=settings,
        thresholds=thresholds,
        alert_system=alert_system,
        db=db,
        transaction_tracker=transaction_tracker,
        order_manager=order_manager
    )
    logger.info("RiskManagement initialized.")

    # Initialize PositionManagement
    position_management = PositionManagement(
        order_manager=order_manager,
        settings=settings,
        thresholds=thresholds,
        balance_checker=balance_checker,
        trade_validator=trade_validator
    )
    logger.info("PositionManagement initialized.")
    
    # Initialize missing components needed by StrategySelector
    # Initialize Indicators
    indicators = Indicators(settings=settings, thresholds=thresholds)
    logger.info("Indicators initialized.")
    
    # Initialize Whitelist
    whitelist = Whitelist(settings=settings)
    logger.info("Whitelist initialized.")
    
    # Initialize SolanaTrackerAPI
    solana_tracker_api = SolanaTrackerAPI(settings=settings)
    logger.info("SolanaTrackerAPI initialized.")
    
    # Get price_monitor from MarketData
    price_monitor = market_data.price_monitor
    logger.info("PriceMonitor reference obtained from MarketData.")
    
    # Get volume_monitor from MarketData or create one
    volume_monitor = VolumeMonitor(db=db, settings=settings, thresholds=thresholds)
    logger.info("VolumeMonitor initialized.")
    
    # Use MarketData as monitoring service
    monitoring_service = market_data
    logger.info("Monitoring service set to MarketData.")
    
    # Initialize EntryExitStrategy first as StrategySelector and StrategyEvaluator might need it
    entry_exit_strategy = EntryExitStrategy(
        settings=settings,
        db=db,
        trade_queue=None, # Operates in signal generation mode when used by StrategyEvaluator
        market_data=market_data,
        whitelist=whitelist,
        blacklist=blacklist,
        thresholds=thresholds,
        wallet_manager=wallet_manager
        # indicators=indicators # EES will calculate its own or use data from price events
    )
    await entry_exit_strategy.initialize(order_manager=order_manager) # Pass order_manager during initialization
    logger.info("EntryExitStrategy initialized standalone.")

    strategy_selector = StrategySelector(
        settings=settings,
        thresholds=thresholds,
        filters_config=filters_config,
        db=db,
        market_data=market_data,
        indicators=indicators,
        price_monitor=price_monitor,
        trade_queue=trade_queue,
        entry_exit_strategy=entry_exit_strategy,
        wallet_manager=wallet_manager,
        order_manager=order_manager,
        risk_management=risk_management,
        position_management=position_management,
        alert_system=alert_system,
        whitelist=whitelist,
        blacklist=blacklist
    )
    logger.info("StrategySelector initialized with more dependencies.")

    token_metrics = TokenMetrics(
        settings=settings,
        db=db,
        price_monitor=price_monitor,
        thresholds=thresholds,
        filter_manager=filter_manager,
        whitelist=whitelist,
        monitoring=monitoring_service, # Pass the MarketData instance as monitoring service
        indicators=indicators,
        platform_tracker=platform_tracker,
        volume_monitor=volume_monitor,
        strategy_selector=strategy_selector,
        solana_client=solana_client
    )
    logger.info("TokenMetrics initialized.")

    # Now initialize TokenScanner with proper TokenMetrics
    logger.info("Initializing TokenScanner...")
    token_scanner = TokenScanner(
        db=db, 
        settings=settings, 
        thresholds=thresholds, 
        filter_manager=filter_manager, 
        market_data=market_data, 
        dexscreener_api=dexscreener_api,
        token_metrics=token_metrics,
        rugcheck_api=rugcheck_api # Optional, but pass if available
    )
    if not await token_scanner.initialize():
        logger.critical("Failed to initialize TokenScanner. Exiting.")
        # ... (cleanup including dexscreener_api, market_data, filter_manager, etc.)
        await dexscreener_api.close()
        await market_data.close() # MarketData close will handle its internal PriceMonitor
        # filter_manager may have resources (like its own http_client if not shared) - check its close method
        if hasattr(filter_manager, 'close') and asyncio.iscoroutinefunction(filter_manager.close):
            await filter_manager.close()
        if proxy_manager: await proxy_manager.close_session()
        if http_client: await http_client.aclose()
        if solana_client: await solana_client.close()
        if db: await db.close()
        return None
    logger.info("TokenScanner initialized successfully.")

    # DataFetcher - initialized as it was before, TokenScanner does not directly use it.
    data_fetcher = DataFetcher(settings=settings)
    logger.info("DataFetcher initialized.")

    # Initialize TradeExecutor if available
    trade_executor_instance = None
    try:
        from execution.trade_executor import TradeExecutor
        trade_executor_instance = TradeExecutor(
            settings=settings,
            order_manager=order_manager,
            transaction_tracker=transaction_tracker,
            db=db,
            wallet_manager=wallet_manager,
            market_data=market_data
        )
        await trade_executor_instance.initialize()
        logger.info("TradeExecutor initialized.")
    except ImportError:
        logger.warning("TradeExecutor class not found. Using None - StrategyEvaluator will work without trade execution.")
        trade_executor_instance = None
    except Exception as e:
        logger.warning(f"TradeExecutor initialization failed: {e}. Using None.")
        trade_executor_instance = None

    # --- Strategy Components ---
    strategy_evaluator = StrategyEvaluator(
        market_data=market_data,
        db=db,
        settings=settings,
        thresholds=thresholds,
        trade_executor=trade_executor_instance,
        wallet_manager=wallet_manager,
        indicators=indicators,
        trade_queue=trade_queue,
        order_manager=order_manager,
        entry_exit_strategy=entry_exit_strategy,
        strategy_selector=strategy_selector
    )
    await strategy_evaluator.initialize_strategies() # Initialize internal strategies (will use provided EES or create if None)
    logger.info("StrategyEvaluator initialized.")
    
    # --- Paper Trading System ---
    paper_trading = PaperTrading(
        settings=settings,
        db=db,
        wallet_manager=wallet_manager,
        price_monitor=price_monitor
    )
    await paper_trading.load_persistent_state()
    logger.info("PaperTrading system initialized.")
    
    # --- Focused Monitoring Manager ---
    focused_monitoring = FocusedMonitoringManager(
        settings=settings,
        market_data=market_data,
        db=db
    )
    logger.info("FocusedMonitoringManager initialized.")
    
    # --- Blockchain Listener ---
    blockchain_listener = BlockchainListener(settings=settings, callback=None)
    await blockchain_listener.initialize()
    logger.info("BlockchainListener initialized.")
    
    # --- Hybrid Monitoring Manager ---
    hybrid_monitoring = HybridMonitoringManager(
        settings=settings,
        blockchain_listener=blockchain_listener,
        market_data=market_data,
        token_db=db,
        logger=logger
    )
    logger.info("HybridMonitoringManager initialized.")
    
    # --- Enhanced PumpSwap Parser with Helius Stream ---
    from data.pumpswap_parser import PumpSwapParser
    from config.blockchain_logging import setup_blockchain_logger
    
    async def helius_pump_callback(price_data):
        """Handle Helius Pump AMM price updates from enhanced parser"""
        try:
            # **DISABLED: The blockchain transaction data is NOT price data!**
            # This was causing confusion by treating transaction amounts as prices
            logger.debug(f"🔧 Helius blockchain event received (not processing as price): {price_data.get('signature', 'unknown')[:8]}...")
            return  # Skip processing blockchain events as prices
            
            # **OLD CODE DISABLED:**
            # if price_data.get('price'):
            #     # Extract mint from the price data or use a default approach
            #     token_mint = price_data.get('token_mint') or price_data.get('mint', 'unknown')
            #     
            #     # Update market data with the price
            #     await market_data._update_realtime_token_state(
            #         mint_address=token_mint,
            #         event_type='helius_pump_swap',
            #         price=price_data['price'],
            #         raw_event_data=price_data,
            #         dex_id='pumpswap',
            #         pair_address=price_data.get('signature', 'unknown')[:8]
            #     )
            #     
            #     price = price_data['price']
            #     decimals_info = f"(decimals: {price_data.get('token_decimals_used', 'unknown')})"
            #     method_info = price_data.get('calculation_method', 'unknown')
            #     
            #     # Cross-validate with Jupiter API
            #     mint_address = price_data.get('mint_address')
            #     if mint_address:
            #         try:
            #             import httpx
            #             async with httpx.AsyncClient(timeout=5.0) as client:
            #                 response = await client.get(f"https://lite-api.jup.ag/price/v2?ids={mint_address}&vsToken=So11111111111111111111111111111111111111112")
            #                 if response.status_code == 200:
            #                     jupiter_data = response.json()
            #                     if 'data' in jupiter_data and mint_address in jupiter_data['data']:
            #                         jupiter_price = float(jupiter_data['data'][mint_address]['price'])
            #                         price_diff_pct = abs(price - jupiter_price) / jupiter_price * 100 if jupiter_price > 0 else 0
            #                         
            #                         if price_diff_pct > 50:  # More than 50% difference
            #                             logger.warning(f"🚨 PRICE MISMATCH: Blockchain: {price:.8f} SOL vs Jupiter: {jupiter_price:.8f} SOL (diff: {price_diff_pct:.1f}%) [{method_info}]")
            #                         else:
            #                             logger.info(f"✅ Price validated: {price:.8f} SOL (Jupiter: {jupiter_price:.8f} SOL, diff: {price_diff_pct:.1f}%) [{method_info}]")
            #                         return  # Skip the normal log if we have validation
            #         except Exception as e:
            #             logger.debug(f"Jupiter validation failed: {e}")
            #     
            #     logger.info(f"🎯 Helius Pump price update: {price:.8f} SOL {decimals_info} [{method_info}]")
        except Exception as e:
            logger.error(f"Error processing Helius pump callback: {e}")
    
    # Initialize enhanced PumpSwap parser with stream capability
    blockchain_logger = setup_blockchain_logger("PumpSwapStream")
    helius_pump_parser = PumpSwapParser(settings, blockchain_logger)
    
    # Start the Helius Pump AMM stream
    await helius_pump_parser.start_helius_pump_stream(callback=helius_pump_callback)
    logger.info("🚀 Enhanced PumpSwap parser with Helius stream initialized and started")
    
    # --- Filters ---
    # FilterManager setup can occur here if it's a standalone component
    # Example: filter_manager = FilterManager(settings, db, ...)
    # await filter_manager.initialize()
    # logger.info("FilterManager initialized.")

    components = {
        "settings": settings,
        "db": db,
        "thresholds": thresholds,
        "filters_config": filters_config,
        "market_data": market_data,
        "dexscreener_api": dexscreener_api,
        "rugcheck_api": rugcheck_api,         # Add rugcheck_api
        "solsniffer_api": solsniffer_api,     # Add solsniffer_api
        "solana_tracker_api": solana_tracker_api, # Add solana_tracker_api
        "twitter_check": twitter_check,       # Add twitter_check
        "filter_manager": filter_manager,     # Add filter_manager
        "whitelist": whitelist,               # Add whitelist
        "blacklist": blacklist,               # Add blacklist
        "alert_system": alert_system,         # Add alert_system
        "risk_management": risk_management,     # Add risk_management
        "position_management": position_management, # Add position_management
        "indicators": indicators,             # Add indicators
        "platform_tracker": platform_tracker, # Add platform_tracker
        "volume_monitor": volume_monitor,     # Add volume_monitor
        "strategy_selector": strategy_selector, # Add strategy_selector
        "token_metrics": token_metrics,       # Add token_metrics
        "data_fetcher": data_fetcher,         # Add data_fetcher
        "token_scanner": token_scanner,
        "http_client": http_client,
        "solana_client": solana_client,
        "wallet_manager": wallet_manager,
        "trade_queue": trade_queue, # Keep for other potential uses
        "order_manager": order_manager, # Keep for other potential uses
        "transaction_tracker": transaction_tracker, # Keep for other potential uses
        "trade_executor": trade_executor_instance, # Add to components (could be None)
        "strategy_evaluator": strategy_evaluator, # Add to components
        "paper_trading": paper_trading, # Add paper trading system
        "blockchain_listener": blockchain_listener, # Add blockchain listener
        "focused_monitoring": focused_monitoring, # Add focused monitoring manager
        "hybrid_monitoring": hybrid_monitoring, # Add hybrid monitoring manager
        "helius_pump_parser": helius_pump_parser, # Add enhanced PumpSwap parser with Helius stream
        "realtime_manager": realtime_manager, # Add real-time event manager
        # "filter_manager": filter_manager, # If used
    }
    # Log component initialization times or other relevant info
    end_time = time.time()
    logger.info(f"--- Core Components Initialized ({end_time - start_time:.2f}s) ---")
    return components # Return as a dictionary


# Add this where other async functions are defined before main()

async def manage_top_token_trading(
    db: TokenDatabase, 
    market_data: MarketData, 
    settings: Settings, 
    token_scanner: TokenScanner,
    strategy_evaluator: Optional[StrategyEvaluator],
    shutdown_event: asyncio.Event
):
    logger.info("Starting Top 3 Token Trading Manager...")
    current_monitored_tokens: Dict[str, Dict] = {}  # Track multiple tokens: {mint: {pair_address, dex_id}}
    max_tokens = 3  # Monitor top 3 tokens

    while not shutdown_event.is_set():
        try:
            logger.info("Top 3 Token Manager: Checking for new best tokens...")
            # Get the top 3 tokens for trading
            top_tokens = await db.get_top_tokens_for_trading(limit=max_tokens, include_inactive_tokens=True)

            if top_tokens:
                logger.info(f"Top 3 Token Manager: Found {len(top_tokens)} candidates")
                
                # Get current token mints
                new_token_mints = {token.mint for token in top_tokens}
                current_token_mints = set(current_monitored_tokens.keys())
                
                # Stop monitoring tokens that are no longer in top 3
                tokens_to_stop = current_token_mints - new_token_mints
                for mint_to_stop in tokens_to_stop:
                    logger.info(f"Top 3 Token Manager: Stopping monitoring for token no longer in top 3: {mint_to_stop}")
                    await market_data.stop_monitoring_token(mint_to_stop)
                    await db.update_token_monitoring_status(mint_to_stop, 'stopped')
                    if strategy_evaluator:
                        strategy_evaluator.stop_evaluating_token(mint_to_stop)
                    del current_monitored_tokens[mint_to_stop]
                
                # Start monitoring new tokens
                tokens_to_start = new_token_mints - current_token_mints
                for token in top_tokens:
                    if token.mint in tokens_to_start:
                        logger.info(f"Top 3 Token Manager: Starting monitoring for new token: {token.mint} (Pair: {token.pair_address}, DEX: {token.dex_id})")
                        success = await market_data.start_monitoring_token(mint=token.mint)
                        if success:
                            current_monitored_tokens[token.mint] = {
                                'pair_address': token.pair_address,
                                'dex_id': token.dex_id
                            }
                            await db.update_token_monitoring_status(token.mint, 'active')
                            logger.info(f"Top 3 Token Manager: Successfully started monitoring {token.mint}")
                            if strategy_evaluator:
                                strategy_evaluator.start_evaluating_token(token.mint, token.pair_address, token.dex_id)
                        else:
                            logger.error(f"Top 3 Token Manager: Failed to start monitoring for {token.mint}")
                
                # Log current status
                logger.info(f"Top 3 Token Manager: Currently monitoring {len(current_monitored_tokens)} tokens: {list(current_monitored_tokens.keys())}")
                
            else:
                logger.info("Top 3 Token Manager: No suitable tokens found for trading in this cycle.")
                # Stop all current monitoring if no tokens found
                for mint in list(current_monitored_tokens.keys()):
                    logger.info(f"Top 3 Token Manager: No candidates found, stopping monitoring for {mint}")
                    await market_data.stop_monitoring_token(mint)
                    await db.update_token_monitoring_status(mint, 'stopped')
                    if strategy_evaluator:
                        strategy_evaluator.stop_evaluating_token(mint)
                current_monitored_tokens.clear()
            
            # Wait for the next cycle
            logger.info(f"Top 3 Token Manager: Sleeping for {settings.TOP_TOKEN_SELECTION_INTERVAL_SECONDS} seconds.")
            await asyncio.sleep(settings.TOP_TOKEN_SELECTION_INTERVAL_SECONDS)
        except asyncio.CancelledError:
            logger.info("Top 3 Token Trading Manager shutting down due to cancellation.")
            break


# --- Main Asynchronous Function ---
async def main():
    """Main entry point for the trading bot."""
    # Get a logger instance
    logger = get_logger(__name__) # Ensure logger is the configured one
    logger.info("🚀 --- SUPERTRADEX BOT STARTING --- 🚀")
    logger.info(f"Version: {get_git_commit_hash()}") # Log git commit hash
    logger.info(f"Python Version: {sys.version}")
    logger.info(f"Current Working Directory: {os.getcwd()}")
    logger.info(f"Max Runtime: {'Unlimited' if MAX_RUNTIME_SECONDS is None else f'{MAX_RUNTIME_SECONDS}s'}")
    
    # Create PID file for web dashboard monitoring
    pid_file = Path("supertradex.pid")
    try:
        with open(pid_file, "w") as f:
            f.write(str(os.getpid()))
        logger.info(f"Created PID file: {pid_file} with PID: {os.getpid()}")
    except Exception as e:
        logger.warning(f"Could not create PID file: {e}")
    
    # Create a global shutdown event
    shutdown_event = asyncio.Event()

    # Setup signal handlers for graceful shutdown
    loop = asyncio.get_event_loop()
    
    # Store original signal handlers
    original_sigint_handler = signal.getsignal(signal.SIGINT)
    original_sigterm_handler = signal.getsignal(signal.SIGTERM)

    def signal_handler_wrapper():
        # This synchronous wrapper schedules the asynchronous signal_handler_async.
        logger.info("Signal received by wrapper, initiating shutdown sequence...")
        if not shutdown_event.is_set():
            # logger is captured from main's scope
            # The third argument to the old signal_handler_async (components) is removed.
            asyncio.create_task(signal_handler_async(shutdown_event, logger))
        else:
            logger.info("Signal received by wrapper, but shutdown_event already set.")

    # Register signal handlers
    for sig in (signal.SIGINT, signal.SIGTERM):
        loop.add_signal_handler(sig, signal_handler_wrapper)

    components = None # Initialize components to None
    try:
        logger.info(f"Starting SuperTradex Bot. Commit: {get_git_commit_hash()}")
        logger.info(f"Max runtime: {MAX_RUNTIME_SECONDS if MAX_RUNTIME_SECONDS else 'Indefinite'}")

        # --- Initialize Real-time Event Manager ---
        realtime_manager = RealtimeEventManager()
        await realtime_manager.start_websocket_server()

        # --- Initialize Components ---
        # All component initialization is now within initialize_components
        components = await initialize_components(settings, realtime_manager)
        
        # Check if initialization failed
        if components is None:
            logger.critical("Component initialization failed. Exiting.")
            return

        # Set app context for FastAPI routes
        set_app_context(components, settings)

        # Extract necessary components (assuming components is a dictionary)
        db = components["db"]
        market_data = components["market_data"]
        token_scanner = components["token_scanner"]
        strategy_evaluator = components.get("strategy_evaluator") # Use .get() for optional components
        trade_scheduler = components.get("trade_scheduler") # Use .get() for optional components
        paper_trading = components.get("paper_trading") # Get paper trading system
        focused_monitoring = components.get("focused_monitoring") # Get focused monitoring manager
        blockchain_listener = components.get("blockchain_listener") # Get blockchain listener

        if not all([db, market_data, token_scanner]): # Basic check
            logger.critical("One or more critical components (DB, MarketData, TokenScanner) failed to initialize. Exiting.")
            return

        # --- Initialize Focused Monitoring for Real-time Price Comparison ---
        if focused_monitoring:
            logger.info("🎯 Starting focused monitoring initialization...")
            await focused_monitoring.initialize_focused_monitoring()
            # Subscribe to blockchain events for real-time price comparison
            await focused_monitoring.subscribe_to_pool_events()
            logger.info("✅ Focused monitoring initialized for real-time price comparison")
        
        # --- Initialize Hybrid Monitoring for Priority-Based Token Monitoring ---
        hybrid_monitoring = components.get("hybrid_monitoring")
        if hybrid_monitoring:
            logger.info("🎯 Setting up hybrid monitoring with priority-based token strategies...")
            
            # Add BONK as HIGH priority token with direct account subscription
            bonk_success = await hybrid_monitoring.add_high_priority_token(
                mint="DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
                symbol="BONK",
                pool_address="8BnEgHoWFysVcuFFX7QztDmzuH8r5ZFvyP3sYwn1XTh6",  # Raydium V4 BONK/SOL
                dex_id="raydium_v4"
            )
            
            if bonk_success:
                logger.info("🔥 BONK added as HIGH priority with direct account subscription")
            else:
                logger.error("❌ Failed to add BONK as high priority token")
            
            # Add SAPHI as MEDIUM priority token with program logs
            saphi_success = await hybrid_monitoring.add_medium_priority_token(
                mint="7ZYyESa8TkuoBVFi5seeLPr7B3MeLvyPgEgv5MDTpump",  # ✅ FIXED: Use same mint as focused monitoring
                symbol="SAPHI",
                dex_id="pumpswap"
            )
            
            if saphi_success:
                logger.info("📡 SAPHI added as MEDIUM priority with program logs")
            
            # Set up blockchain event callback for hybrid monitoring
            if blockchain_listener:
                existing_callback = blockchain_listener._callback
                
                async def hybrid_callback(event_data):
                    # Route to hybrid monitoring first
                    await hybrid_monitoring.handle_blockchain_event(event_data)
                    # Then call existing callback if it exists
                    if existing_callback:
                        await existing_callback(event_data)
                
                blockchain_listener.set_callback(hybrid_callback)
                logger.info("🔗 Hybrid monitoring blockchain callback integrated")
            
            logger.info("✅ Hybrid monitoring initialized with priority-based token strategies")
        
        # --- Enable Paper Trading for Focused Tokens ---
        if paper_trading:
            logger.info("📄 Paper trading system ready for focused tokens")

        logger.info("--- All Components Initialized and Ready --- ")
        
        # The signal_handler_wrapper defined above will correctly use the shutdown_event and logger
        # from the main() scope. No redefinition or complex passing of 'components' to the
        # signal handler itself is needed with the new approach, as the 'finally' block handles cleanup.
        # Old comments regarding this can be removed or ignored.


        # --- Start Background Tasks ---
        background_tasks = []
        
        # Start the token scanner
        scanner_task = asyncio.create_task(token_scanner.run_scan_loop(shutdown_event))
        background_tasks.append(scanner_task)
        logger.info("TokenScanner task started.")

        # Start the MarketData service (e.g., WebSocket connections, price updates)
        market_data_task = asyncio.create_task(market_data.start_monitoring())
        background_tasks.append(market_data_task)
        logger.info("MarketData monitoring task started.")

        # Start the TradeScheduler if available and initialized
        if trade_scheduler:
            scheduler_task = asyncio.create_task(trade_scheduler.run(shutdown_event))
            background_tasks.append(scheduler_task)
            logger.info("TradeScheduler task started.")
        else:
            logger.info("TradeScheduler not available or not initialized, task not started.")
            
        # Initialize and Start the BlockchainListener's main loop if enabled
        # DISABLED: Using new pool-specific subscriptions instead
        # if settings.USE_BLOCKCHAIN_LISTENER:
        #     if hasattr(market_data, 'initialize_blockchain_listener') and callable(market_data.initialize_blockchain_listener):
        #         logger.info("Initializing MarketData's BlockchainListener...")
        #         await market_data.initialize_blockchain_listener() # Call the initialization method
        #         
        #         if hasattr(market_data, 'blockchain_listener') and market_data.blockchain_listener:
        #             listener_instance = market_data.blockchain_listener
        #             if hasattr(listener_instance, 'run_forever') and callable(listener_instance.run_forever):
        #                 logger.info("Starting BlockchainListener.run_forever() task...")
        #                 blockchain_listener_task = asyncio.create_task(listener_instance.run_forever())
        #                 background_tasks.append(blockchain_listener_task)
        #                 logger.info("BlockchainListener.run_forever() task started.")
        #             else:
        #                 logger.warning("MarketData's blockchain_listener does not have a callable run_forever method.")
        #         else:
        #             logger.warning("MarketData.initialize_blockchain_listener() called, but market_data.blockchain_listener is still not available.")
        #     else:
        #         logger.warning("MarketData does not have an initialize_blockchain_listener method.")
        # else:
        #     logger.info("BlockchainListener not enabled (USE_BLOCKCHAIN_LISTENER is false).")
        logger.info("🚫 Old BlockchainListener disabled - using pool-specific subscriptions instead")

        # Start the Top Token Trading Manager
        top_token_manager_task = asyncio.create_task(
            manage_top_token_trading(
                db=db,
                market_data=market_data,
                settings=settings,
                token_scanner=token_scanner, # Pass the TokenScanner instance
                strategy_evaluator=strategy_evaluator, # Pass StrategyEvaluator
                shutdown_event=shutdown_event
            )
        )
        background_tasks.append(top_token_manager_task)
        logger.info("Top Token Trading Manager task started.")
        
        # Start the StrategyEvaluator periodic evaluation task
        if strategy_evaluator and hasattr(strategy_evaluator, 'run_evaluations'):
            strategy_evaluator_task = asyncio.create_task(strategy_evaluator.run_evaluations(shutdown_event))
            background_tasks.append(strategy_evaluator_task)
            logger.info("StrategyEvaluator periodic evaluation task started.")
        elif strategy_evaluator:
            logger.warning("StrategyEvaluator instance exists but does not have 'run_evaluations' method. Periodic evaluation will not run.")
        else:
            logger.info("StrategyEvaluator not available, periodic evaluation task not started.")

        # Start Focused Monitoring Background Tasks
        if focused_monitoring:
            # Task 1: Update and display PriceMonitor prices every 30 seconds
            async def price_monitor_update_task():
                logger.info("🎯 Starting PriceMonitor price update task...")
                while not shutdown_event.is_set():
                    try:
                        await focused_monitoring.update_price_monitor_display()
                        await asyncio.sleep(30)  # Update every 30 seconds
                    except asyncio.CancelledError:
                        logger.info("PriceMonitor update task cancelled")
                        break
                    except Exception as e:
                        logger.error(f"Error in PriceMonitor update task: {e}")
                        await asyncio.sleep(30)  # Continue after error
            
            # Task 2: Print comparison summary every 60 seconds
            async def comparison_summary_task():
                logger.info("📊 Starting price comparison summary task...")
                await asyncio.sleep(60)  # Wait 60s before first summary
                while not shutdown_event.is_set():
                    try:
                        focused_monitoring.print_focused_comparison()
                        await asyncio.sleep(60)  # Print summary every 60 seconds
                    except asyncio.CancelledError:
                        logger.info("Comparison summary task cancelled")
                        break
                    except Exception as e:
                        logger.error(f"Error in comparison summary task: {e}")
                        await asyncio.sleep(60)  # Continue after error
            
            price_monitor_task = asyncio.create_task(price_monitor_update_task())
            background_tasks.append(price_monitor_task)
            logger.info("🎯 Focused PriceMonitor update task started (30s intervals)")
            
            comparison_task = asyncio.create_task(comparison_summary_task())
            background_tasks.append(comparison_task)
            logger.info("📊 Focused price comparison summary task started (60s intervals)")
            
            # Add the WebSocket message processing task to background tasks
            if focused_monitoring.message_processing_task:
                background_tasks.append(focused_monitoring.message_processing_task)
                logger.info("🔄 Added focused monitoring message processing task to background tasks")
        else:
            logger.warning("Focused monitoring not available, price comparison tasks not started.")
        
        # Start Hybrid Monitoring Background Tasks
        if hybrid_monitoring:
            # Task: Print hybrid monitoring status every 2 minutes
            async def hybrid_status_task():
                logger.info("🎯 Starting hybrid monitoring status reporting...")
                await asyncio.sleep(120)  # Wait 2 minutes before first report
                while not shutdown_event.is_set():
                    try:
                        await hybrid_monitoring.print_status_report()
                        await asyncio.sleep(120)  # Report every 2 minutes
                    except asyncio.CancelledError:
                        logger.info("Hybrid monitoring status task cancelled")
                        break
                    except Exception as e:
                        logger.error(f"Error in hybrid monitoring status task: {e}")
                        await asyncio.sleep(120)  # Continue after error
            
            hybrid_task = asyncio.create_task(hybrid_status_task())
            background_tasks.append(hybrid_task)
            logger.info("🎯 Hybrid monitoring status reporting task started (2min intervals)")
        else:
            logger.warning("Hybrid monitoring not available, status reporting not started.")

        # **ADDED: Jupiter API Price Fetching Task**
        async def jupiter_price_fetching_task():
            """Fetch real prices from Jupiter API for monitored tokens"""
            logger.info("💰 Starting Jupiter API price fetching task...")
            await asyncio.sleep(10)  # Wait 10 seconds before first fetch
            while not shutdown_event.is_set():
                try:
                    # Get currently monitored tokens
                    monitored_tokens = await db.get_tokens_with_status('active')
                    if monitored_tokens:
                        mint_addresses = [token.mint for token in monitored_tokens[:5]]  # Limit to top 5
                        
                        # Fetch prices from Jupiter API
                        try:
                            import httpx
                            mint_ids = ",".join(mint_addresses)
                            url = f"https://lite-api.jup.ag/price/v2?ids={mint_ids}&vsToken=So11111111111111111111111111111111111111112"
                            
                            async with httpx.AsyncClient(timeout=10.0) as client:
                                response = await client.get(url)
                                if response.status_code == 200:
                                    jupiter_data = response.json()
                                    
                                    if 'data' in jupiter_data and jupiter_data['data']:
                                        for mint_address in mint_addresses:
                                            if mint_address in jupiter_data['data']:
                                                price_data = jupiter_data['data'][mint_address]
                                                if price_data and 'price' in price_data:
                                                    jupiter_price = float(price_data['price'])
                                                    
                                                    # **PRICE VALIDATION** - Reject unrealistic prices
                                                    if jupiter_price > 10.0:
                                                        token_info = next((t for t in monitored_tokens if t.mint == mint_address), None)
                                                        symbol = token_info.symbol if token_info and token_info.symbol else mint_address[:8]
                                                        logger.warning(f"🚨 JUPITER_API price validation FAILED: {symbol} | {mint_address[:8]}... | {jupiter_price:.8f} SOL is unrealistic (>10 SOL). Skipping.")
                                                        continue
                                                    
                                                    if jupiter_price <= 0:
                                                        token_info = next((t for t in monitored_tokens if t.mint == mint_address), None)
                                                        symbol = token_info.symbol if token_info and token_info.symbol else mint_address[:8]
                                                        logger.warning(f"🚨 JUPITER_API price validation FAILED: {symbol} | {mint_address[:8]}... | {jupiter_price:.8f} SOL is invalid (<=0). Skipping.")
                                                        continue
                                                    
                                                    # Update market data with Jupiter price
                                                    await market_data._update_realtime_token_state(
                                                        mint_address=mint_address,
                                                        event_type='jupiter_api_price',
                                                        price=jupiter_price,
                                                        raw_event_data=price_data,
                                                        dex_id='jupiter_aggregator',
                                                        pair_address='jupiter_api'
                                                    )
                                                    
                                                    # **BROADCAST REAL-TIME UPDATE**
                                                    if realtime_manager:
                                                        token_info = next((t for t in monitored_tokens if t.mint == mint_address), None)
                                                        symbol = token_info.symbol if token_info and token_info.symbol else mint_address[:8]

                                                        await realtime_manager.broadcast_token_update({
                                                            "mint": mint_address,
                                                            "symbol": symbol,
                                                            "price_sol": jupiter_price,
                                                            "price_usd": jupiter_price * 200,  # Approximate USD conversion
                                                            "source": "jupiter_api",
                                                            "timestamp": time.time()
                                                        })
                                                    
                                                    # Get token symbol for logging
                                                    token_info = next((t for t in monitored_tokens if t.mint == mint_address), None)
                                                    symbol = token_info.symbol if token_info and token_info.symbol else mint_address[:8]
                                                    
                                                    logger.info(f"💰 JUPITER_API price: {symbol} | {mint_address[:8]}... | {jupiter_price:.8f} SOL [jupiter_api] ✅")
                                                else:
                                                    logger.debug(f"Jupiter API: No price data for {mint_address[:8]}...")
                                            else:
                                                logger.debug(f"Jupiter API: Token {mint_address[:8]}... not found in response")
                                    else:
                                        logger.warning("Jupiter API returned no price data")
                                else:
                                    logger.warning(f"Jupiter API error: {response.status_code}")
                        except (httpx.ConnectError, httpx.TimeoutException, OSError) as e:
                            logger.warning(f"Jupiter API network error (will retry): {e}")
                        except Exception as e:
                            logger.error(f"Jupiter API fetch failed: {e}")
                    
                    # Wait 30 seconds before next fetch
                    await asyncio.sleep(30)
                except asyncio.CancelledError:
                    logger.info("Jupiter price fetching task cancelled")
                    break
                except Exception as e:
                    logger.error(f"Error in Jupiter price fetching task: {e}")
                    await asyncio.sleep(30)

        jupiter_task = asyncio.create_task(jupiter_price_fetching_task())
        background_tasks.append(jupiter_task)
        logger.info("💰 Jupiter API price fetching task started (30s intervals)")

        # --- Start FastAPI Server ---
        # Configuration for Uvicorn
        # Ensure Uvicorn is imported
        try:
            import uvicorn
            from uvicorn_log_config import UVICORN_LOGGING_CONFIG # Import custom log config
            
            # Make sure settings.API_HOST and settings.API_PORT are defined
            api_host = getattr(settings, 'API_HOST', '127.0.0.1')
            api_port = getattr(settings, 'API_PORT', 8000)

            logger.info(f"Starting FastAPI server on {api_host}:{api_port}")
            
            # Configure Uvicorn to run the FastAPI app
            # Use the imported logging config
            config = uvicorn.Config(app_instance, host=api_host, port=api_port, log_config=UVICORN_LOGGING_CONFIG)
            server = uvicorn.Server(config)
            
            # Run Uvicorn in a separate thread or as an asyncio task
            # To allow other asyncio tasks to run concurrently.
            # Running in a separate thread is often simpler for Uvicorn.
            # However, for graceful shutdown, running as an asyncio task is better.
            # server.run() # This is blocking
            
            # Start Uvicorn as an asyncio task
            uvicorn_task = asyncio.create_task(server.serve())
            background_tasks.append(uvicorn_task)
            logger.info("Uvicorn server task started.")

        except ImportError:
            logger.warning("Uvicorn not installed. FastAPI server will not run. Run 'pip install uvicorn[standard]'")
        except AttributeError as e:
            logger.error(f"FastAPI/Uvicorn configuration error: {e}. Check API_HOST/API_PORT in settings. Server will not run.", exc_info=True)
        except Exception as e:
            logger.error(f"Failed to start FastAPI server: {e}", exc_info=True)


        # --- Main Application Loop (Keep Alive) ---
        start_main_loop_time = time.time()
        while not shutdown_event.is_set():
            # Check max runtime
            if MAX_RUNTIME_SECONDS and (time.time() - start_main_loop_time > MAX_RUNTIME_SECONDS):
                logger.info(f"Max runtime of {MAX_RUNTIME_SECONDS}s reached. Initiating shutdown.")
                shutdown_event.set()
                break
            
            # Main loop can perform periodic checks or just sleep
            # logger.debug("Main loop iteration...")
            await asyncio.sleep(settings.MAIN_LOOP_SLEEP_INTERVAL_S) # Sleep for a configured interval

        logger.info("Shutdown event set. Exiting main loop.")

    except Exception as e:
        logger.critical(f"CRITICAL ERROR in main execution: {e}", exc_info=True)
    finally:
        logger.info("--- Main `finally` block: Initiating Graceful Shutdown ---")
        
        # Ensure shutdown_event is set if an exception caused early exit or if not set by signal
        if not shutdown_event.is_set():
            logger.info("Main `finally` block: Shutdown event was not set (e.g., due to an exception), setting it now.")
            shutdown_event.set() # Ensures subsequent checks for shutdown_event are true
        
        # Call the helper to close all components
        # Make sure `components` dictionary is available here.
        # It should be, due to its definition at the start of the `try` block.
        if components and isinstance(components, dict): # Ensure components were initialized and is a dictionary
            logger.info("Main `finally` block: Closing all components.")
            await close_all_components(components) 
        else:
            logger.warning("Main `finally` block: Components dictionary not available or not initialized for shutdown.")

        # Explicitly close Solana client and HTTP client if not managed by components
        # These are usually passed to components which should manage their lifecycle (e.g., closing sessions)
        # However, if they were created in `initialize_components` and not passed to a component that closes them,
        # or if some components failed to initialize, we might need to close them here.
        # For now, let's assume components handle their resources.
        # Example:
        # if 'solana_client' in locals() and solana_client:
        #     await solana_client.close()
        # if 'http_client' in locals() and http_client:
        #     await http_client.aclose()
        #     logger.info("HTTP client closed.")

        # Wait for all background tasks to complete
        if 'background_tasks' in locals() and background_tasks:
            logger.info(f"Waiting for {len(background_tasks)} background tasks to complete...")
            # Set a timeout for waiting for tasks
            # Gather with return_exceptions=True to prevent one failed task from stopping others
            # Cancel pending tasks to ensure they terminate if they don't respect shutdown_event quickly
            for task in background_tasks:
                if not task.done():
                    task.cancel()
            
            results = await asyncio.gather(*background_tasks, return_exceptions=True)
            for i, result in enumerate(results):
                task_name = background_tasks[i].get_name() if hasattr(background_tasks[i], 'get_name') else f"Task-{i}"
                if isinstance(result, asyncio.CancelledError):
                    logger.info(f"Background task {task_name} was cancelled during shutdown.")
                elif isinstance(result, Exception):
                    logger.error(f"Background task {task_name} raised an exception during shutdown: {result}", exc_info=result)
            logger.info("All background tasks processed for shutdown.")
        
        # Deregister our asyncio signal handlers
        logger.info("Main `finally` block: Removing custom asyncio signal handlers.")
        if loop and not loop.is_closed(): # Ensure loop is available and not closed
            for sig in (signal.SIGINT, signal.SIGTERM):
                try:
                    loop.remove_signal_handler(sig)
                    logger.info(f"Main `finally` block: Removed asyncio signal handler for {sig}.")
                except ValueError: 
                    logger.warning(f"Main `finally` block: Asyncio signal handler for {sig} not found or already removed.")
                except RuntimeError as e: 
                    logger.warning(f"Main `finally` block: Error removing asyncio signal handler for {sig}: {e}")
                except Exception as e:
                    logger.error(f"Main `finally` block: Unexpected error removing asyncio signal handler for {sig}: {e}", exc_info=True)
        else:
            logger.warning("Main `finally` block: Event loop not available or closed, skipping removal of asyncio signal handlers.")

        # Restore original OS-level signal handlers
        logger.info("Main `finally` block: Restoring original OS-level signal handlers.")
        try:
            if original_sigint_handler is not None:
                signal.signal(signal.SIGINT, original_sigint_handler)
                logger.info("Main `finally` block: Restored original SIGINT handler.")
            else: # If original was None, it implies default or no handler, SIG_DFL is python's default upon start if not inherited
                signal.signal(signal.SIGINT, signal.SIG_DFL)
                logger.info("Main `finally` block: Restored SIGINT handler to default (SIG_DFL) as original was None.")

            if original_sigterm_handler is not None:
                signal.signal(signal.SIGTERM, original_sigterm_handler)
                logger.info("Main `finally` block: Restored original SIGTERM handler.")
            else:
                signal.signal(signal.SIGTERM, signal.SIG_DFL)
                logger.info("Main `finally` block: Restored SIGTERM handler to default (SIG_DFL) as original was None.")
        except Exception as e: 
            logger.error(f"Main `finally` block: Error restoring original OS-level signal handlers: {e}", exc_info=True)
        
        logger.info("--- Main `finally` block: Shutdown process complete ---")
        # asyncio_mqtt_client.close() # Example if there were other global resources
        # if http_client: await http_client.aclose() # Example

    return 0 # Return 0 for success, 1 for error (or specific codes)


def write_pid_file():
    """Writes the current process ID to main.pid."""
    try:
        pid = os.getpid()
        with open("main.pid", "w") as f:
            f.write(str(pid))
        # Use print here because logger might not be initialized
        print(f"[PID_MANAGER] Wrote PID {pid} to main.pid")
    except Exception as e:
        print(f"[PID_MANAGER] CRITICAL: Failed to write PID file: {e}")

def remove_pid_file():
    """Removes the main.pid file if it exists."""
    try:
        if os.path.exists("main.pid"):
            os.remove("main.pid")
            try:
                logger.info("PID file removed.")
            except NameError:
                print("PID file removed.")
    except Exception as e:
        try:
            logger.error(f"Error removing PID file: {e}")
        except NameError:
            print(f"Error removing PID file: {e}")


# --- Entry Point --- #
if __name__ == "__main__":
    write_pid_file() # Write PID file at the very start
    main_exit_code = 0 # Default success
    try:
        # Run main and get the exit code it returns
        main_exit_code = asyncio.run(main())

    except KeyboardInterrupt:
        # Use logger if possible, otherwise print
        try: logger.info("KeyboardInterrupt received, exiting.")
        except NameError: print("KeyboardInterrupt received, exiting.")
        main_exit_code = 1 # Indicate interruption
    except Exception as e:
        # This top-level catch might catch errors during asyncio.run setup itself
        try: logger.critical(f"Unhandled exception at top level __main__: {e}", exc_info=True)
        except NameError: print(f"CRITICAL: Unhandled exception at top level __main__: {e}")
        main_exit_code = 1 # Set failure exit code
    finally:
        # Explicitly shutdown logging here ensures it happens even if asyncio.run errors early
        logging.shutdown()
        remove_pid_file() # Remove PID file on exit
        sys.exit(main_exit_code) # Use the captured/determined exit code


        
async def get_monitoring_priority_counts():
    """
    Get counts of tokens being monitored at each priority level
    
    Returns:
        dict: Counts by priority level
    """
    if not market_data:
        return {"high": 0, "medium": 0, "low": 0, "total": 0}
        
    result = {"high": 0, "medium": 0, "low": 0, "total": 0}
    
    for token_address, token_info in market_data._monitored_tokens.items():
        priority = token_info.get('priority', 'low')
        if priority in result:
            result[priority] += 1
        result["total"] += 1
        
    return result
    
def get_success_rate(metrics, monitoring_type):
    """
    Calculate success rate for a specific monitoring type
    
    Args:
        metrics: Metrics data
        monitoring_type: Type of monitoring to calculate for
    
    Returns:
        float: Success rate percentage
    """
    if "primary" not in metrics or "fallback" not in metrics:
        return 0.0

# --- Module-level FastAPI App Setup ---
# Create FastAPI app instance at module level
app = FastAPI(title="SuperTradeX API", description="Real-time trading dashboard API", version="1.0.0")

# Global variables for FastAPI routes
_app_components = None
_app_settings = None

def set_app_context(components, settings):
    """Set the app context for route handlers"""
    global _app_components, _app_settings
    _app_components = components
    _app_settings = settings

# Include routers and setup routes
try:
    from api.routes.metrics_router import router as metrics_router
    from api.routes.control_router import router as control_router
    from api.routes.config_router import router as config_router
    from api.routes.data_router import router as data_router

    app.include_router(metrics_router, prefix="/api/metrics")
    app.include_router(control_router, prefix="/api/control")
    app.include_router(config_router, prefix="/api/config")
    app.include_router(data_router, prefix="/api/data")
    print("✅ FastAPI routers included at module level")
except ImportError as e:
    print(f"⚠️ API modules not available: {e}")

# Setup routes after app creation
def setup_api_routes():
    """Setup API routes for the FastAPI app."""

    @app.get("/api/metrics/blockchain")
    async def get_blockchain_metrics():
        """Get metrics about blockchain listener reliability and fallback operations."""
        if not _app_components or "market_data" not in _app_components:
            return {"error": "MarketData not initialized", "timestamp": time.time()}

        market_data = _app_components["market_data"]
        if not hasattr(market_data, "get_blockchain_listener_metrics"):
            return {"error": "MarketData not initialized", "timestamp": time.time()}

        metrics = await market_data.get_blockchain_listener_metrics()
        metrics["monitoring_strategy"] = {
            "description": "Combined monitoring strategy statistics",
            "priority_counts": await get_monitoring_priority_counts(),
            "success_rates": {
                "direct_account": get_success_rate(metrics, "direct_account"),
                "log_subscription": get_success_rate(metrics, "logs"),
                "webhook": 0.0,
                "price_monitor": 100.0,
            },
        }
        return metrics

    @app.get("/api/paper-trading/balance")
    async def get_paper_trading_balance():
        """Get current paper trading SOL balance."""
        try:
            if _app_components and "db" in _app_components:
                db = _app_components["db"]
                balance_data = await db.get_paper_summary_value("paper_sol_balance")
                if balance_data and balance_data.get("value_float") is not None:
                    return {"balance": balance_data["value_float"], "currency": "SOL"}
                return {"balance": 0.0, "currency": "SOL"}
            return {"error": "Database not available", "balance": 0.0, "currency": "SOL"}
        except Exception as exc:
            return {"error": str(exc), "balance": 0.0, "currency": "SOL"}

    @app.get("/api/paper-trading/positions")
    async def get_paper_trading_positions():
        """Get all current paper trading positions."""
        try:
            if _app_components and "db" in _app_components:
                db = _app_components["db"]
                positions = await db.get_all_paper_positions()
                position_list = []
                for position in positions:
                    token_info = await db.get_token_by_mint(position.mint)
                    symbol = token_info.symbol if token_info else position.mint[:8]
                    position_list.append(
                        {
                            "mint": position.mint,
                            "symbol": symbol,
                            "quantity": position.quantity,
                            "total_cost_usd": position.total_cost_usd,
                            "average_price_usd": position.average_price_usd,
                            "last_updated": position.last_updated.isoformat() if position.last_updated else None,
                        }
                    )
                return {"positions": position_list}
            return {"error": "Database not available", "positions": []}
        except Exception as exc:
            return {"error": str(exc), "positions": []}

    @app.get("/api/paper-trading/tokens")
    async def get_available_tokens():
        """Get tokens available for paper trading."""
        try:
            if _app_components and "db" in _app_components:
                db = _app_components["db"]
                tokens = await db.get_top_tokens_for_trading(limit=10)
                token_list = []
                for token in tokens:
                    current_price_sol = 0.000001
                    if token.api_data and "price_sol" in token.api_data:
                        current_price_sol = token.api_data["price_sol"]
                    elif token.price:
                        current_price_sol = token.price / 150
                    token_list.append(
                        {
                            "mint": token.mint,
                            "symbol": token.symbol or "UNKNOWN",
                            "name": token.name or "",
                            "price_sol": current_price_sol,
                            "price_usd": token.price or 0,
                            "volume_24h": token.volume_24h or 0,
                            "liquidity": token.liquidity or 0,
                            "dex_id": token.dex_id or "",
                            "rugcheck_score": token.rugcheck_score or 0,
                        }
                    )
                return {"tokens": token_list}
            return {"error": "Database not available", "tokens": []}
        except Exception as exc:
            return {"error": str(exc), "tokens": []}

    @app.post("/api/paper-trading/execute")
    async def execute_paper_trade():
        """Execute a paper trade."""
        return {"success": False, "message": "Paper trade execution endpoint needs implementation"}

setup_api_routes()