"""
Configuration for GUI refactoring
Manages feature flags and refactoring settings
"""

import os
import json
from pathlib import Path
from utils.logger import logger

class RefactoringConfig:
    """Manages refactoring feature flags"""
    
    CONFIG_FILE = "refactoring_config.json"
    DEFAULT_FLAGS = {
        'USE_GITEA_HANDLER': True,  # Enable for Progress Bar support
        'USE_PROCESS_HANDLER': True,  # Enable for better logging
        'USE_PROJECT_HANDLER': False,
        'USE_UI_HELPERS': False,
        'ENABLE_DEBUG_LOGGING': False,
        'FORCE_ORIGINAL_IMPLEMENTATION': False  # Emergency override
    }
    
    def __init__(self):
        self.config_path = Path.home() / ".claude_project_manager" / self.CONFIG_FILE
        self.flags = self.DEFAULT_FLAGS.copy()
        self._load_config()
        self._check_env_overrides()
    
    def _load_config(self):
        """Load configuration from file"""
        try:
            if self.config_path.exists():
                with open(self.config_path, 'r') as f:
                    loaded_flags = json.load(f)
                    # Only update known flags
                    for key, value in loaded_flags.items():
                        if key in self.flags:
                            self.flags[key] = value
                            logger.info(f"Loaded refactoring flag: {key} = {value}")
        except Exception as e:
            logger.error(f"Failed to load refactoring config: {e}")
    
    def _check_env_overrides(self):
        """Check for environment variable overrides"""
        # Global override
        if os.getenv('CPM_USE_NEW_HANDLERS'):
            logger.info("Enabling all refactored handlers via environment variable")
            for key in ['USE_GITEA_HANDLER', 'USE_PROCESS_HANDLER', 
                       'USE_PROJECT_HANDLER', 'USE_UI_HELPERS']:
                self.flags[key] = True
        
        # Individual overrides
        for flag in self.flags:
            env_var = f"CPM_{flag}"
            if os.getenv(env_var):
                value = os.getenv(env_var).lower() in ('true', '1', 'yes')
                self.flags[flag] = value
                logger.info(f"Override from env: {flag} = {value}")
    
    def save_config(self):
        """Save current configuration to file"""
        try:
            self.config_path.parent.mkdir(parents=True, exist_ok=True)
            with open(self.config_path, 'w') as f:
                json.dump(self.flags, f, indent=2)
            logger.info(f"Saved refactoring config to {self.config_path}")
        except Exception as e:
            logger.error(f"Failed to save refactoring config: {e}")
    
    def get(self, flag_name: str, default=None):
        """Get a flag value"""
        return self.flags.get(flag_name, default)
    
    def set(self, flag_name: str, value: bool):
        """Set a flag value"""
        if flag_name in self.flags:
            self.flags[flag_name] = value
            logger.info(f"Set refactoring flag: {flag_name} = {value}")
        else:
            logger.warning(f"Unknown refactoring flag: {flag_name}")
    
    def enable_handler(self, handler_name: str):
        """Enable a specific handler"""
        # Map handler names to flags
        handler_map = {
            'gitea': 'USE_GITEA_HANDLER',
            'process': 'USE_PROCESS_HANDLER',
            'project': 'USE_PROJECT_HANDLER',
            'ui': 'USE_UI_HELPERS'  # Note: not _HANDLER suffix
        }
        flag_name = handler_map.get(handler_name.lower())
        if flag_name and flag_name in self.flags:
            self.set(flag_name, True)
        else:
            logger.warning(f"Unknown handler: {handler_name}")
    
    def disable_all(self):
        """Disable all refactoring features"""
        for flag in self.flags:
            if flag.startswith('USE_'):
                self.flags[flag] = False
        logger.info("All refactoring features disabled")
    
    def get_status(self):
        """Get status of all flags"""
        return {
            "config_file": str(self.config_path),
            "flags": self.flags.copy()
        }

# Global instance
refactoring_config = RefactoringConfig()