"""Simple configuration loader - Single Watch Folder"""

import os
import yaml
import platform
from typing import Dict, Any, Optional

class Config:
    """Simple configuration class with dot notation access"""
    
    def __init__(self, config_path: str = None):
        if config_path is None:
            config_path = os.path.join(os.path.dirname(__file__), '..', 'config.yaml')
        
        config_path = os.path.normpath(config_path)
        
        with open(config_path, 'r', encoding='utf-8') as f:
            self._data = yaml.safe_load(f)
        
        self.system = platform.system()
    
    def get(self, key: str, default=None):
        """Get value using dot notation"""
        keys = key.split('.')
        value = self._data
        for k in keys:
            if isinstance(value, dict):
                value = value.get(k)
                if value is None:
                    return default
            else:
                return default
        return value
    
    def get_client(self, client_code: str) -> Dict:
        """Get client configuration"""
        return self.get(f'clients.{client_code}', {})
    
    def get_client_broker(self, client_code: str) -> str:
        """Get broker type for client"""
        return self.get(f'clients.{client_code}.broker', 'firstock')
    
    def get_client_overrides(self, client_code: str, symbol: str) -> Dict:
        """Get symbol overrides for client"""
        return self.get(f'clients.{client_code}.overrides.{symbol}', {})
    
    def get_client_limits(self, client_code: str) -> Dict:
        """Get limits for client"""
        client_limits = self.get(f'clients.{client_code}.limits', {})
        default_limits = self.get('defaults.limits', {})
        
        merged = default_limits.copy()
        merged.update(client_limits)
        return merged
    
    def get_symbol_config(self, client_code: str, symbol: str) -> Dict:
        """Get complete symbol configuration for client"""
        default_config = self.get(f'defaults.symbol.{symbol}', {})
        overrides = self.get_client_overrides(client_code, symbol)
        
        config = default_config.copy()
        config.update(overrides)
        return config
    
    def get_max_quantity(self, symbol: str) -> int:
        """Get max quantity per order for symbol"""
        return self.get(f'defaults.max_quantity.{symbol}', 650)
    
    def get_broker_params(self, client_code: str) -> Dict:
        """Get broker parameters for order placement"""
        broker_type = self.get_client_broker(client_code)
        return self.get(f'broker.{broker_type}', {})
    
    def get_client_credentials(self, client_code: str) -> Dict:
        """Get client credentials"""
        client = self.get_client(client_code)
        if not client:
            return {}
        
        credentials = client.get('credentials', {})
        
        # Remove None values
        credentials = {k: v for k, v in credentials.items() if v is not None}
        
        return credentials
    
    def get_client_id(self, client_code: str) -> str:
        """Get client ID for the client"""
        credentials = self.get_client_credentials(client_code)
        broker_type = self.get_client_broker(client_code)
        
        if broker_type == 'zerodha':
            return credentials.get('api_key', client_code)
        else:
            return credentials.get('user_id', client_code)
    
    def is_zerodha_client(self, client_code: str) -> bool:
        """Check if client uses Zerodha"""
        return self.get_client_broker(client_code) == 'zerodha'
    
    def get_watch_folder(self) -> str:
        """Get the single watch folder path"""
        watch_folder = self.get('watch_folder', '/var/www/html/ACTIONS_MTF_MH/')
        
        # Create if doesn't exist
        if not os.path.exists(watch_folder):
            os.makedirs(watch_folder, exist_ok=True)
        
        return watch_folder
    
    def get_lock_dir(self) -> str:
        """Get lock directory for current platform"""
        if self.system == 'Windows':
            return self.get('settings.lock_dir_windows', 'C:\\Temp\\')
        else:
            return self.get('settings.lock_dir', '/tmp/')
    
    def get_processed_folder(self, client_code: str) -> str:
        """Get processed folder for client (subfolder in watch folder)"""
        watch_folder = self.get_watch_folder()
        client_id = self.get_client_id(client_code)
        return os.path.join(watch_folder, client_id)
    
    def get_runtime_settings(self) -> Dict:
        """Get runtime settings"""
        return self.get('settings', {})
    
    def get_all_clients(self) -> Dict:
        """Get all clients"""
        return self.get('clients', {})
    
    def get_enabled_clients(self) -> Dict:
        """Get enabled clients only"""
        clients = self.get_all_clients()
        return {code: cfg for code, cfg in clients.items() if cfg.get('enabled', True)}