# src/core/event_bus.py
from PySide6.QtCore import QObject, Signal

class EventBus(QObject):
    """Zentrale Signal-Verteilung zwischen Modulen"""
    
    # Editor Events
    file_opened = Signal(str)           # path
    file_saved = Signal(str)            # path
    file_modified = Signal(str, bool)   # path, is_modified
    
    # Analyzer Events
    analysis_requested = Signal(str)        # path
    analysis_complete = Signal(dict)        # results
    errors_found = Signal(list)             # error_list
    
    # Builder Events
    build_requested = Signal(str)           # project_path
    build_progress = Signal(int, str)       # percent, message
    build_complete = Signal(bool, str)      # success, output_path
    
    # Project Events
    project_opened = Signal(str)            # project_path
    project_closed = Signal()
    
    _instance = None
    
    @classmethod
    def instance(cls):
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance

# src/gui/main_window.py
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("DevCenter")
        self.setMinimumSize(1200, 800)
        
        self._setup_ui()
        self._setup_menu()
        self._setup_toolbar()
        self._setup_statusbar()
        self._connect_signals()
        self._restore_geometry()
    
    def _setup_ui(self):
        # Tab-Widget als zentrales Element
        self.tab_widget = QTabWidget()
        self.tab_widget.setTabsClosable(True)
        self.tab_widget.setMovable(True)
        self.setCentralWidget(self.tab_widget)
        
        # Dock Widgets für Panels
        self._setup_project_dock()
        self._setup_output_dock()

# src/models/project.py
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional
import json

@dataclass
class DevCenterProject:
    name: str
    path: Path
    main_file: Optional[str] = None
    python_version: str = "3.11"
    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
    last_opened: Optional[str] = None
    
    # Build Settings
    build_output_dir: str = "dist"
    build_icon: Optional[str] = None
    build_onefile: bool = True
    build_console: bool = True
    
    # Analyzer Settings
    auto_analyze: bool = True
    analyze_on_save: bool = True
    
    def save(self):
        config_path = self.path / ".devcenter" / "project.json"
        config_path.parent.mkdir(exist_ok=True)
        with open(config_path, 'w', encoding='utf-8') as f:
            json.dump(self.__dict__, f, indent=2, default=str)
    
    @classmethod
    def load(cls, path: Path) -> 'DevCenterProject':
        config_path = path / ".devcenter" / "project.json"
        with open(config_path, 'r', encoding='utf-8') as f:
            data = json.load(f)
        return cls(**data)

# src/gui/widgets/project_explorer.py
class ProjectExplorer(QDockWidget):
    file_double_clicked = Signal(str)
    
    def __init__(self, parent=None):
        super().__init__("Project Explorer", parent)
        self.tree = QTreeView()
        self.model = QFileSystemModel()
        # ... Setup

# src/gui/dialogs/welcome_dialog.py
class WelcomeDialog(QDialog):
    """Startbildschirm mit Recent Projects"""
    
    project_selected = Signal(str)
    new_project_requested = Signal()

# src/modules/editor/code_editor.py
from PySide6.QtWidgets import QPlainTextEdit

class CodeEditor(QPlainTextEdit):
    """Python Code Editor basierend auf PythonBox"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self._setup_editor()
        self._setup_lexer()
        self._setup_margins()
        self._setup_autocompletion()
    
    def _setup_editor(self):
        # Font
        font = QFont("Consolas", 11)
        self.setFont(font)
        
        # Tabs
        self.setTabWidth(4)
        self.setIndentationsUseTabs(False)
        self.setAutoIndent(True)
        
        # Brace Matching
        self.setBraceMatching(QsciScintilla.BraceMatch.SloppyBraceMatch)
        
        # Current Line Highlight
        self.setCaretLineVisible(True)
        self.setCaretLineBackgroundColor(QColor("#ffffc0"))
    
    def _setup_margins(self):
        # Zeilennummern
        self.setMarginType(0, QsciScintilla.MarginType.NumberMargin)
        self.setMarginWidth(0, "00000")
        
        # Folding
        self.setFolding(QsciScintilla.FoldStyle.BoxedTreeFoldStyle)

# src/modules/editor/editor_manager.py
class EditorManager:
    """Verwaltet alle offenen Editor-Tabs"""
    
    def open_file(self, path: str) -> CodeEditor:
        # Prüfen ob bereits offen
        if path in self.open_files:
            self.tab_widget.setCurrentWidget(self.open_files[path])
            return self.open_files[path]
        
        # Neue Tab erstellen
        editor = CodeEditor()
        editor.load_file(path)
        
        tab_index = self.tab_widget.addTab(editor, Path(path).name)
        self.open_files[path] = editor
        
        # Modified-Indikator
        editor.modificationChanged.connect(
            lambda modified: self._update_tab_title(path, modified)
        )
        
        return editor

# src/gui/widgets/output_panel.py
class OutputPanel(QDockWidget):
    """Ausgabe-Panel für Run & Build"""
    
    def __init__(self, parent=None):
        super().__init__("Output", parent)
        
        self.tabs = QTabWidget()
        
        # Run Output
        self.run_output = QPlainTextEdit()
        self.run_output.setReadOnly(True)
        self.tabs.addTab(self.run_output, "Run")
        
        # Build Output
        self.build_output = QPlainTextEdit()
        self.build_output.setReadOnly(True)
        self.tabs.addTab(self.build_output, "Build")
        
        # Problems (für Analyzer)
        self.problems_list = QTreeWidget()
        self.tabs.addTab(self.problems_list, "Problems")

# src/modules/editor/python_runner.py
class PythonRunner(QObject):
    output_received = Signal(str)
    error_received = Signal(str)
    finished = Signal(int)  # exit_code
    
    def run(self, script_path: str, args: list = None):
        self.process = QProcess()
        self.process.readyReadStandardOutput.connect(self._handle_stdout)
        self.process.readyReadStandardError.connect(self._handle_stderr)
        self.process.finished.connect(self._handle_finished)
        
        self.process.start("python", [script_path] + (args or []))

# src/modules/analyzer/ast_analyzer.py
import ast
from dataclasses import dataclass
from typing import List, Set

@dataclass
class AnalysisResult:
    imports: List[str]
    unused_imports: List[str]
    classes: List[dict]
    functions: List[dict]
    undefined_names: List[str]
    duplicate_code: List[dict]
    complexity_warnings: List[str]

class ASTAnalyzer:
    def analyze_file(self, path: str) -> AnalysisResult:
        with open(path, 'r', encoding='utf-8') as f:
            source = f.read()
        
        tree = ast.parse(source)
        
        return AnalysisResult(
            imports=self._extract_imports(tree),
            unused_imports=self._find_unused_imports(tree, source),
            classes=self._extract_classes(tree),
            functions=self._extract_functions(tree),
            undefined_names=self._find_undefined(tree),
            duplicate_code=self._find_duplicates(source),
            complexity_warnings=self._check_complexity(tree)
        )

# src/modules/analyzer/problems_provider.py
class ProblemsProvider(QObject):
    problems_updated = Signal(list)
    
    def analyze_and_report(self, path: str):
        result = self.analyzer.analyze_file(path)
        
        problems = []
        for imp in result.unused_imports:
            problems.append({
                'type': 'warning',
                'message': f"Unused import: {imp}",
                'file': path,
                'line': self._find_import_line(imp),
                'source': 'analyzer'
            })
        
        self.problems_updated.emit(problems)

# src/modules/analyzer/encoding_fixer.py
import ftfy

class EncodingFixer:
    def fix_file(self, path: str, backup: bool = True) -> bool:
        with open(path, 'r', encoding='utf-8', errors='replace') as f:
            content = f.read()
        
        fixed = ftfy.fix_text(content)
        
        if fixed != content:
            if backup:
                shutil.copy(path, path + '.bak')
            
            with open(path, 'w', encoding='utf-8') as f:
                f.write(fixed)
            return True
        return False

# src/modules/analyzer/code_navigator.py
class CodeNavigator:
    """Schnelle Navigation zu Klassen/Funktionen"""
    
    def get_symbols(self, path: str) -> List[dict]:
        # Liefert Liste von {name, type, line}
        pass

# src/modules/builder/build_engine.py
from PyInstaller.__main__ import run as pyinstaller_run

class BuildEngine(QObject):
    progress = Signal(int, str)
    finished = Signal(bool, str)
    
    def build(self, config: BuildConfig):
        self.progress.emit(10, "Preparing build...")
        
        # PyInstaller Args zusammenbauen
        args = [
            config.main_file,
            f'--distpath={config.output_dir}',
            f'--workpath={config.temp_dir}',
            f'--specpath={config.temp_dir}',
        ]
        
        if config.onefile:
            args.append('--onefile')
        
        if config.icon:
            args.append(f'--icon={config.icon}')
        
        if not config.console:
            args.append('--windowed')
        
        # Hidden imports
        for imp in config.hidden_imports:
            args.append(f'--hidden-import={imp}')
        
        self.progress.emit(30, "Running PyInstaller...")
        
        try:
            pyinstaller_run(args)
            self.progress.emit(100, "Build complete!")
            self.finished.emit(True, config.output_dir)
        except Exception as e:
            self.finished.emit(False, str(e))

# src/modules/builder/build_config.py
@dataclass
class BuildConfig:
    main_file: str
    output_dir: str = "dist"
    onefile: bool = True
    console: bool = True
    icon: Optional[str] = None
    name: Optional[str] = None
    hidden_imports: List[str] = field(default_factory=list)
    data_files: List[tuple] = field(default_factory=list)
    exclude_modules: List[str] = field(default_factory=list)

# src/modules/builder/icon_builder.py
from PIL import Image

ICO_SIZES = [(16,16), (24,24), (32,32), (48,48), (64,64), (128,128), (256,256)]

class IconBuilder:
    def convert_to_ico(self, input_path: str, output_path: str = None):
        img = Image.open(input_path)
        img = self._make_square(img)
        
        if output_path is None:
            output_path = Path(input_path).with_suffix('.ico')
        
        img.save(output_path, format='ICO', sizes=ICO_SIZES)
        return output_path

# src/modules/builder/license_generator.py
import subprocess

class LicenseGenerator:
    def generate(self, output_path: str):
        result = subprocess.run(
            ['pip-licenses', '--with-license-file', '--format=plain'],
            capture_output=True,
            text=True
        )
        
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write("THIRD-PARTY LICENSES\n")
            f.write("=" * 50 + "\n\n")
            f.write(result.stdout)

# Toolbar Button "Build" (F6)
def on_build_clicked(self):
    project = self.project_manager.current_project
    
    if not project.main_file:
        self.ask_for_main_file()
        return
    
    config = BuildConfig(
        main_file=project.main_file,
        output_dir=project.path / project.build_output_dir,
        icon=project.build_icon,
        onefile=project.build_onefile,
        console=project.build_console
    )
    
    self.build_engine.build(config)

# src/modules/builder/store_packager.py
class StorePackager:
    def generate_manifest(self, config: StoreConfig):
        manifest = f'''<?xml version="1.0" encoding="utf-8"?>
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10">
  <Identity Name="{config.package_name}"
            Publisher="{config.publisher}"
            Version="{config.version}" />
  <Properties>
    <DisplayName>{config.display_name}</DisplayName>
    <PublisherDisplayName>{config.publisher_name}</PublisherDisplayName>
    <Logo>{config.logo_path}</Logo>
  </Properties>
  <!-- ... -->
</Package>'''
        return manifest

# src/modules/ai/ai_service.py
from anthropic import Anthropic

class AIService(QObject):
    response_received = Signal(str)
    error_occurred = Signal(str)
    
    def __init__(self):
        self.client = Anthropic(api_key=self._get_api_key())
    
    def _get_api_key(self) -> str:
        # Aus Settings oder Keyring
        return keyring.get_password("devcenter", "anthropic_api_key")
    
    async def complete(self, prompt: str, context: str = None):
        messages = []
        if context:
            messages.append({"role": "user", "content": context})
        messages.append({"role": "user", "content": prompt})
        
        response = await self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            messages=messages
        )
        
        self.response_received.emit(response.content[0].text)

# src/modules/ai/ai_panel.py
class AIAssistantPanel(QDockWidget):
    def __init__(self):
        super().__init__("AI Assistant")
        
        layout = QVBoxLayout()
        
        # Chat History
        self.chat_history = QTextBrowser()
        layout.addWidget(self.chat_history)
        
        # Input
        self.input_field = QPlainTextEdit()
        self.input_field.setMaximumHeight(100)
        layout.addWidget(self.input_field)
        
        # Buttons
        btn_layout = QHBoxLayout()
        self.send_btn = QPushButton("Send")
        self.context_btn = QPushButton("Include Code")
        btn_layout.addWidget(self.context_btn)
        btn_layout.addWidget(self.send_btn)
        layout.addLayout(btn_layout)

# src/modules/ai/code_generator.py
class CodeGenerator:
    PROMPTS = {
        'explain': "Explain this code:\n\n{code}",
        'improve': "Suggest improvements for this code:\n\n{code}",
        'document': "Add docstrings to this code:\n\n{code}",
        'test': "Generate unit tests for this code:\n\n{code}",
    }
    
    def generate(self, action: str, code: str):
        prompt = self.PROMPTS[action].format(code=code)
        return self.ai_service.complete(prompt)

# Planner → Coder → Checker Workflow
class DevelopmentLoop:
    async def run(self, task_description: str, project_context: str):
        # 1. Planner
        plan = await self.ai_service.complete(
            f"Plan the implementation for: {task_description}\nContext: {project_context}"
        )
        
        # 2. Coder
        code = await self.ai_service.complete(
            f"Implement this plan:\n{plan}"
        )
        
        # 3. Checker
        review = await self.ai_service.complete(
            f"Review this implementation:\n{code}"
        )
        
        return {'plan': plan, 'code': code, 'review': review}

# src/modules/filemanager/profiler_bridge.py
class ProfilerBridge:
    """Verbindung zu ProFiler für Datei-Index"""
    
    def __init__(self, db_path: str):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
    
    def index_project(self, project_path: str):
        """Indiziert alle Dateien im Projekt"""
        for file in Path(project_path).rglob("*.py"):
            self._index_file(file)
    
    def search(self, query: str) -> List[dict]:
        """Suche in indizierten Dateien"""
        cursor = self.conn.execute(
            "SELECT path, content FROM files WHERE content LIKE ?",
            (f"%{query}%",)
        )
        return [{'path': row[0], 'content': row[1]} for row in cursor]

# src/gui/dialogs/search_dialog.py
class GlobalSearchDialog(QDialog):
    """Projekt-weite Suche (Ctrl+Shift+F)"""
    
    file_selected = Signal(str, int)  # path, line

# src/modules/filemanager/sync_manager.py
class SyncManager:
    """Automatische Backups mit ProSync-Logik"""
    
    def backup_project(self, project_path: str, target_path: str):
        # WAL Checkpoint für SQLite
        self._checkpoint_databases(project_path)
        
        # Sync mit Excludes
        excludes = ['__pycache__', '.git', 'dist', 'build', '*.pyc']
        self._sync_directory(project_path, target_path, excludes)

# src/gui/dialogs/settings_dialog.py
class SettingsDialog(QDialog):
    """Zentrale Einstellungen"""
    
    def __init__(self):
        self.tabs = QTabWidget()
        self.tabs.addTab(GeneralSettingsPage(), "General")
        self.tabs.addTab(EditorSettingsPage(), "Editor")
        self.tabs.addTab(BuildSettingsPage(), "Build")
        self.tabs.addTab(AISettingsPage(), "AI")
        self.tabs.addTab(SyncSettingsPage(), "Sync")

# Wichtige Shortcuts
SHORTCUTS = {
    'Ctrl+N': 'New File',
    'Ctrl+O': 'Open File',
    'Ctrl+S': 'Save',
    'Ctrl+Shift+S': 'Save All',
    'F5': 'Run',
    'Ctrl+F5': 'Run Without Debugging',
    'F6': 'Build',
    'Ctrl+Shift+B': 'Build Configuration',
    'Ctrl+F': 'Find',
    'Ctrl+H': 'Replace',
    'Ctrl+Shift+F': 'Find in Files',
    'Ctrl+G': 'Go to Line',
    'Ctrl+P': 'Quick Open',
    'Ctrl+Shift+O': 'Go to Symbol',
    'F2': 'Rename',
    'Ctrl+Space': 'Autocomplete',
}