"""
Settings UI Tests

Tests for the settings interface including:
- General settings
- Plugin management
- Hotkey configuration
- Appearance/theming
- Data and backup
"""


class SettingsUITests:
    """Test suite for settings UI."""
    
    name = "Settings UI"
    icon = "⚙️"
    description = "Tests all settings categories including plugins, hotkeys, and appearance"
    
    def __init__(self):
        self.tests = {
            'settings_dialog': self.test_settings_dialog,
            'general_settings': self.test_general_settings,
            'plugin_management': self.test_plugin_management,
            'hotkey_configuration': self.test_hotkey_configuration,
            'appearance_settings': self.test_appearance_settings,
            'data_backup': self.test_data_backup,
            'updates_tab': self.test_updates_tab,
            'about_tab': self.test_about_tab,
            'save_cancel': self.test_save_cancel,
            'dependency_checking': self.test_dependency_checking,
        }
    
    def test_settings_dialog(self) -> dict:
        """Test settings dialog creation."""
        try:
            from core.overlay_window import OverlayWindow
            
            issues = []
            
            # Check settings dialog method
            if not hasattr(OverlayWindow, '_open_settings'):
                issues.append("_open_settings method missing")
            
            # Check settings tabs
            if not hasattr(OverlayWindow, '_create_plugins_settings_tab'):
                issues.append("_create_plugins_settings_tab missing")
            
            if not hasattr(OverlayWindow, '_create_hotkeys_settings_tab'):
                issues.append("_create_hotkeys_settings_tab missing")
            
            if not hasattr(OverlayWindow, '_create_appearance_settings_tab'):
                issues.append("_create_appearance_settings_tab missing")
            
            if not hasattr(OverlayWindow, '_create_about_tab'):
                issues.append("_create_about_tab missing")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'error'
                }
            
            return {
                'passed': True,
                'message': "Settings dialog structure present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking settings dialog: {e}",
                'severity': 'error'
            }
    
    def test_general_settings(self) -> dict:
        """Test general settings tab."""
        try:
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check general tab creation
            if not hasattr(SettingsView, '_create_general_tab'):
                return {
                    'passed': False,
                    'message': "_create_general_tab method missing",
                    'severity': 'warning'
                }
            
            # Check expected UI elements in general settings
            import inspect
            source = inspect.getsource(SettingsView._create_general_tab)
            
            expected_elements = ['theme', 'opacity']
            missing = [e for e in expected_elements if e not in source.lower()]
            
            if missing:
                issues.append(f"General settings missing: {missing}")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "General settings tab present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking general settings: {e}",
                'severity': 'error'
            }
    
    def test_plugin_management(self) -> dict:
        """Test plugin management in settings."""
        try:
            from core.overlay_window import OverlayWindow
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check overlay window methods
            if not hasattr(OverlayWindow, '_create_plugins_settings_tab'):
                issues.append("_create_plugins_settings_tab missing in OverlayWindow")
            
            if not hasattr(OverlayWindow, '_add_plugin_row'):
                issues.append("_add_plugin_row helper missing")
            
            if not hasattr(OverlayWindow, 'settings_checkboxes'):
                issues.append("settings_checkboxes tracking missing")
            
            # Check SettingsView
            if not hasattr(SettingsView, '_create_plugins_tab'):
                issues.append("_create_plugins_tab missing in SettingsView")
            
            if not hasattr(SettingsView, '_populate_plugins_list'):
                issues.append("_populate_plugins_list missing")
            
            if not hasattr(SettingsView, '_toggle_plugin'):
                issues.append("_toggle_plugin missing")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'error'
                }
            
            return {
                'passed': True,
                'message': "Plugin management UI present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking plugin management: {e}",
                'severity': 'error'
            }
    
    def test_hotkey_configuration(self) -> dict:
        """Test hotkey configuration UI."""
        try:
            from core.overlay_window import OverlayWindow
            from core.ui.settings_view import SettingsView
            from core.hotkey_manager import HotkeyManager
            
            issues = []
            recommendations = []
            
            # Check overlay window
            if not hasattr(OverlayWindow, '_create_hotkeys_settings_tab'):
                issues.append("_create_hotkeys_settings_tab missing")
            
            if not hasattr(OverlayWindow, '_reset_hotkeys'):
                issues.append("_reset_hotkeys missing")
            
            # Check SettingsView
            if not hasattr(SettingsView, '_create_hotkeys_tab'):
                issues.append("_create_hotkeys_tab missing in SettingsView")
            
            # Check HotkeyManager
            try:
                hm = HotkeyManager()
                if not hasattr(hm, 'get_all_hotkeys'):
                    issues.append("HotkeyManager.get_all_hotkeys missing")
                
                if not hasattr(hm, 'reset_to_defaults'):
                    recommendations.append("Consider adding reset_to_defaults to HotkeyManager")
            except Exception as e:
                issues.append(f"HotkeyManager not functional: {e}")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'error',
                    'recommendation': recommendations[0] if recommendations else None
                }
            
            return {
                'passed': True,
                'message': "Hotkey configuration UI present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking hotkey configuration: {e}",
                'severity': 'error'
            }
    
    def test_appearance_settings(self) -> dict:
        """Test appearance settings."""
        try:
            from core.overlay_window import OverlayWindow
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check overlay window
            if not hasattr(OverlayWindow, '_create_appearance_settings_tab'):
                issues.append("_create_appearance_settings_tab missing")
            
            if not hasattr(OverlayWindow, '_set_theme_from_settings'):
                issues.append("_set_theme_from_settings missing")
            
            # Check SettingsView
            if not hasattr(SettingsView, '_create_general_tab'):
                # Appearance might be in general tab
                pass
            
            # Check for theme-related controls
            import inspect
            if hasattr(OverlayWindow, '_create_appearance_settings_tab'):
                source = inspect.getsource(OverlayWindow._create_appearance_settings_tab)
                
                if 'theme' not in source.lower():
                    issues.append("Appearance settings missing theme controls")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "Appearance settings present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking appearance settings: {e}",
                'severity': 'error'
            }
    
    def test_data_backup(self) -> dict:
        """Test data and backup settings."""
        try:
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check data tab
            if not hasattr(SettingsView, '_create_data_tab'):
                return {
                    'passed': False,
                    'message': "_create_data_tab missing",
                    'severity': 'warning'
                }
            
            # Check for backup/restore methods
            expected_methods = ['_export_data', '_import_data', '_clear_data']
            
            for method in expected_methods:
                if not hasattr(SettingsView, method):
                    issues.append(f"{method} missing")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "Data and backup features present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking data backup: {e}",
                'severity': 'error'
            }
    
    def test_updates_tab(self) -> dict:
        """Test updates settings tab."""
        try:
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check updates tab
            if not hasattr(SettingsView, '_create_updates_tab'):
                return {
                    'passed': False,
                    'message': "_create_updates_tab missing",
                    'severity': 'warning'
                }
            
            # Check for update check method
            if not hasattr(SettingsView, '_check_updates'):
                issues.append("_check_updates missing")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "Updates tab present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking updates tab: {e}",
                'severity': 'error'
            }
    
    def test_about_tab(self) -> dict:
        """Test about tab."""
        try:
            from core.overlay_window import OverlayWindow
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check overlay window
            if not hasattr(OverlayWindow, '_create_about_tab'):
                issues.append("_create_about_tab missing in OverlayWindow")
            
            # Check SettingsView
            if not hasattr(SettingsView, '_create_about_tab'):
                issues.append("_create_about_tab missing in SettingsView")
            
            # Check for expected content
            if hasattr(OverlayWindow, '_create_about_tab'):
                import inspect
                source = inspect.getsource(OverlayWindow._create_about_tab)
                
                expected = ['version', 'hotkey', 'keyboard']
                missing = [e for e in expected if e not in source.lower()]
                
                if missing:
                    recommendations = [f"Consider adding to about tab: {missing}"]
                else:
                    recommendations = []
            else:
                recommendations = []
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "About tab present",
                'severity': 'info',
                'recommendation': recommendations[0] if recommendations else None
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking about tab: {e}",
                'severity': 'error'
            }
    
    def test_save_cancel(self) -> dict:
        """Test save and cancel functionality."""
        try:
            from core.overlay_window import OverlayWindow
            from core.ui.settings_view import SettingsView
            
            issues = []
            
            # Check overlay window save
            if not hasattr(OverlayWindow, '_save_settings'):
                issues.append("_save_settings missing in OverlayWindow")
            
            if not hasattr(OverlayWindow, '_reload_plugins'):
                issues.append("_reload_plugins missing")
            
            # Check that dialog has proper buttons
            import inspect
            if hasattr(OverlayWindow, '_open_settings'):
                source = inspect.getsource(OverlayWindow._open_settings)
                
                if 'save' not in source.lower() and 'cancel' not in source.lower():
                    issues.append("Save/Cancel buttons may be missing from dialog")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'error'
                }
            
            return {
                'passed': True,
                'message': "Save/Cancel functionality present",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking save/cancel: {e}",
                'severity': 'error'
            }
    
    def test_dependency_checking(self) -> dict:
        """Test plugin dependency checking in settings."""
        try:
            from core.overlay_window import OverlayWindow
            from core.plugin_dependency_manager import get_dependency_manager
            
            issues = []
            
            # Check dependency manager
            try:
                dm = get_dependency_manager()
                
                required_methods = [
                    'has_dependencies',
                    'check_all_dependencies',
                    'get_missing_dependencies_text',
                    'get_plugin_dependencies_text',
                    'install_dependency'
                ]
                
                for method in required_methods:
                    if not hasattr(dm, method):
                        issues.append(f"DependencyManager.{method} missing")
                
            except Exception as e:
                issues.append(f"DependencyManager not available: {e}")
            
            # Check that settings uses dependency manager
            import inspect
            if hasattr(OverlayWindow, '_save_settings'):
                source = inspect.getsource(OverlayWindow._save_settings)
                
                if 'dependency' not in source.lower():
                    issues.append("_save_settings doesn't appear to check dependencies")
            
            if issues:
                return {
                    'passed': False,
                    'message': "; ".join(issues),
                    'severity': 'warning'
                }
            
            return {
                'passed': True,
                'message': "Dependency checking integrated in settings",
                'severity': 'info'
            }
            
        except Exception as e:
            return {
                'passed': False,
                'message': f"Error checking dependency checking: {e}",
                'severity': 'error'
            }