import os
from dotenv import load_dotenv
from typing import Optional
import logging

# Load environment variables from .env file
load_dotenv()

logger = logging.getLogger(__name__)

class Config:
    """Configuration class for the Hyperliquid trading bot."""
    
    # Hyperliquid API Configuration
    HYPERLIQUID_SECRET_KEY: Optional[str] = os.getenv('HYPERLIQUID_SECRET_KEY')    # API generator key
    HYPERLIQUID_WALLET_ADDRESS: Optional[str] = os.getenv('HYPERLIQUID_WALLET_ADDRESS')  # Wallet address
    HYPERLIQUID_TESTNET: bool = os.getenv('HYPERLIQUID_TESTNET', 'true').lower() == 'true'
    
    # Trading Bot Configuration
    DEFAULT_TRADING_TOKEN: str = os.getenv('DEFAULT_TRADING_TOKEN', 'BTC')
    RISK_MANAGEMENT_ENABLED: bool = os.getenv('RISK_MANAGEMENT_ENABLED', 'true').lower() == 'true'
    STOP_LOSS_PERCENTAGE: float = float(os.getenv('STOP_LOSS_PERCENTAGE', '10.0'))
    
    # Telegram Bot Configuration
    TELEGRAM_BOT_TOKEN: Optional[str] = os.getenv('TELEGRAM_BOT_TOKEN')
    TELEGRAM_CHAT_ID: Optional[str] = os.getenv('TELEGRAM_CHAT_ID')
    TELEGRAM_ENABLED: bool = os.getenv('TELEGRAM_ENABLED', 'true').lower() == 'true'
    TELEGRAM_DROP_PENDING_UPDATES: bool = os.getenv('TELEGRAM_DROP_PENDING_UPDATES', 'true').lower() == 'true'
    
    # Custom Keyboard Configuration
    TELEGRAM_CUSTOM_KEYBOARD_ENABLED: bool = os.getenv('TELEGRAM_CUSTOM_KEYBOARD_ENABLED', 'true').lower() == 'true'
    TELEGRAM_CUSTOM_KEYBOARD_LAYOUT: str = os.getenv('TELEGRAM_CUSTOM_KEYBOARD_LAYOUT', '/daily,/performance,/balance|/stats,/positions,/orders|/price,/market,/help,/commands')
    
    # Bot settings
    BOT_HEARTBEAT_SECONDS = int(os.getenv('BOT_HEARTBEAT_SECONDS', '5'))
    
    # Market Monitor settings
    MARKET_MONITOR_CLEANUP_INTERVAL_HEARTBEATS = 120 # Approx every 10 minutes if heartbeat is 5s
    
    # Order settings
    DEFAULT_SLIPPAGE = 0.005  # 0.5%
    
    # Logging
    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO').upper()
    
    # Log file configuration
    LOG_TO_FILE: bool = os.getenv('LOG_TO_FILE', 'true').lower() == 'true'
    LOG_FILE_PATH: str = os.getenv('LOG_FILE_PATH', 'logs/trading_bot.log')
    LOG_MAX_SIZE_MB: int = int(os.getenv('LOG_MAX_SIZE_MB', '10'))
    LOG_BACKUP_COUNT: int = int(os.getenv('LOG_BACKUP_COUNT', '5'))
    LOG_ROTATION_TYPE: str = os.getenv('LOG_ROTATION_TYPE', 'size')  # 'size' or 'time'
    LOG_ROTATION_INTERVAL: str = os.getenv('LOG_ROTATION_INTERVAL', 'midnight')  # for time rotation
    
    @classmethod
    def validate(cls) -> bool:
        """Validate all configuration settings."""
        is_valid = True
        
        # Validate Hyperliquid settings
        if not cls.HYPERLIQUID_WALLET_ADDRESS:
            logger.error("❌ HYPERLIQUID_WALLET_ADDRESS is required")
            is_valid = False
        
        if not cls.HYPERLIQUID_SECRET_KEY:
            logger.error("❌ HYPERLIQUID_SECRET_KEY (API generator key) is required")
            is_valid = False
        
        # Validate Telegram settings (if enabled)
        if cls.TELEGRAM_ENABLED:
            if not cls.TELEGRAM_BOT_TOKEN:
                logger.error("❌ TELEGRAM_BOT_TOKEN is required when Telegram is enabled")
                is_valid = False
            
            if not cls.TELEGRAM_CHAT_ID:
                logger.error("❌ TELEGRAM_CHAT_ID is required when Telegram is enabled")
                is_valid = False
        
        # Validate heartbeat interval
        if cls.BOT_HEARTBEAT_SECONDS < 5:
            logger.error("❌ BOT_HEARTBEAT_SECONDS must be at least 5 seconds to avoid rate limiting")
            is_valid = False
        elif cls.BOT_HEARTBEAT_SECONDS > 600:
            logger.warning("⚠️ BOT_HEARTBEAT_SECONDS is very high (>10 minutes), monitoring may be slow")
        
        # Validate trading settings
        if cls.DEFAULT_TRADING_TOKEN == '':
            logger.error("❌ DEFAULT_TRADING_TOKEN must be set")
            is_valid = False
        
        # Validate logging settings
        if cls.LOG_MAX_SIZE_MB <= 0:
            logger.error("❌ LOG_MAX_SIZE_MB must be positive")
            is_valid = False
        
        if cls.LOG_BACKUP_COUNT < 0:
            logger.error("❌ LOG_BACKUP_COUNT must be non-negative")
            is_valid = False
        
        if cls.LOG_ROTATION_TYPE not in ['size', 'time']:
            logger.error("❌ LOG_ROTATION_TYPE must be 'size' or 'time'")
            is_valid = False
        
        return is_valid
    
    @classmethod
    def get_hyperliquid_config(cls) -> dict:
        """Get Hyperliquid configuration in CCXT format."""
        config = {
            'testnet': cls.HYPERLIQUID_TESTNET,
            'sandbox': cls.HYPERLIQUID_TESTNET,  # CCXT uses sandbox for testnet
        }
        
        # Add authentication if available
        # Hyperliquid CCXT implementation expects:
        # - apiKey: API generator key (SECRET_KEY)  
        # - walletAddress: wallet address (WALLET_ADDRESS)
        # - secret: (optional, set to wallet address for compatibility)
        if cls.HYPERLIQUID_SECRET_KEY:
            config['apiKey'] = cls.HYPERLIQUID_SECRET_KEY  # API generator key
            
        if cls.HYPERLIQUID_WALLET_ADDRESS:
            config['walletAddress'] = cls.HYPERLIQUID_WALLET_ADDRESS  # Wallet address
            config['secret'] = cls.HYPERLIQUID_WALLET_ADDRESS  # Also set as secret for backward compatibility
            
        return config
    
    @classmethod
    def print_config(cls):
        """Print current configuration (hiding sensitive data)."""
        logger.info("🔧 Configuration:")
        logger.info(f"  📡 Hyperliquid Testnet: {cls.HYPERLIQUID_TESTNET}")
        logger.info(f"  🏠 Wallet Address: {'✅ Set' if cls.HYPERLIQUID_WALLET_ADDRESS else '❌ Missing'}")
        logger.info(f"  🔑 API Generator Key: {'✅ Set' if cls.HYPERLIQUID_SECRET_KEY else '❌ Missing'}")
        logger.info(f"  📱 Telegram: {'✅ Enabled' if cls.TELEGRAM_ENABLED else '❌ Disabled'}")
        logger.info(f"  🔍 Log Level: {cls.LOG_LEVEL}")
        logger.info(f"  💾 Log to File: {cls.LOG_TO_FILE}")
        logger.info(f"  ⏱️ Heartbeat: {cls.BOT_HEARTBEAT_SECONDS}s")
        logger.info(f"  💰 DEFAULT_TRADING_TOKEN: {cls.DEFAULT_TRADING_TOKEN}")
        logger.info(f"  🧮 RISK_MANAGEMENT_ENABLED: {cls.RISK_MANAGEMENT_ENABLED}")
        logger.info(f"  🔄 STOP_LOSS_PERCENTAGE: {cls.STOP_LOSS_PERCENTAGE}%")
        logger.info(f"  🤖 TELEGRAM_BOT_TOKEN: {'✅ Set' if cls.TELEGRAM_BOT_TOKEN else '❌ Not Set'}")
        logger.info(f"  💬 TELEGRAM_CHAT_ID: {'✅ Set' if cls.TELEGRAM_CHAT_ID else '❌ Not Set'}")
        logger.info(f"  ⌨️ CUSTOM_KEYBOARD: {'✅ Enabled' if cls.TELEGRAM_CUSTOM_KEYBOARD_ENABLED else '❌ Disabled'}")
        logger.info(f"  🔍 LOG_FILE_PATH: {cls.LOG_FILE_PATH}")
        logger.info(f"  🔄 LOG_MAX_SIZE_MB: {cls.LOG_MAX_SIZE_MB} MB")
        logger.info(f"  🔄 LOG_BACKUP_COUNT: {cls.LOG_BACKUP_COUNT}")
        logger.info(f"  🔄 LOG_ROTATION_TYPE: {cls.LOG_ROTATION_TYPE}")
        logger.info(f"  🔄 LOG_ROTATION_INTERVAL: {cls.LOG_ROTATION_INTERVAL}")