Lsp Setup

"""LSP Auto-Configuration Module.

Provides automatic Language Server Protocol (LSP) configuration for Claude Code.

Philosophy:
- Ruthless simplicity - Standard library only where possible
- Self-contained modules with clear public APIs
- Zero-BS implementation - Every function works
- Regeneratable from specification

Public API (the "studs"):
    LanguageDetector: Detect programming languages in project
    LSPConfigurator: Configure .env file for LSP
    PluginManager: Manage Claude Code LSP plugins
    StatusTracker: Track three-layer LSP setup status
"""

from .language_detector import LanguageDetection, LanguageDetector
from .lsp_configurator import LSPConfigurator
from .mcp_configurator import CCLSPConfig, MCPConfigurator
from .plugin_manager import PluginInstallResult, PluginManager
from .status_tracker import LayerStatus, StatusTracker

__all__ = [
    "LanguageDetector",
    "LanguageDetection",
    "LSPConfigurator",
    "PluginManager",
    "PluginInstallResult",
    "StatusTracker",
    "LayerStatus",
    "MCPConfigurator",
    "CCLSPConfig",
]

__version__ = "0.1.0"

"""Language detection module for LSP Auto-Configuration.

Detects programming languages in project directory by scanning file extensions
and project markers (package.json, Cargo.toml, etc.).

Philosophy:
- Single responsibility: Language detection only
- Standard library only (Path, os, glob)
- Self-contained and regeneratable

Public API:
    LanguageDetection: Result of language detection scan
    LanguageDetector: Main language detection class
"""

import fnmatch
from dataclasses import dataclass
from pathlib import Path


@dataclass
class LanguageDetection:
    """Result of language detection scan."""

    language: str  # e.g., "python", "typescript"
    file_count: int  # Number of files detected
    primary: bool  # True if this is primary project language
    markers: list[str]  # Framework markers found (e.g., "package.json")


class LanguageDetector:
    """Detects programming languages in project directory.

    Scans project files and identifies languages based on:
    - File extensions (.py, .ts, .rs, etc.)
    - Project markers (package.json, Cargo.toml, etc.)
    - Framework-specific files

    Example:
        >>> detector = LanguageDetector(Path("/path/to/project"))
        >>> languages = detector.detect_languages()
        >>> for lang in languages:
        ...     print(f"{lang}: {languages[lang]} files")
    """

    # Language definitions: extensions and project markers
    LANGUAGE_DEFINITIONS = {
        "python": {
            "extensions": [".py", ".pyi", ".pyw"],
            "markers": ["setup.py", "pyproject.toml", "requirements.txt", "Pipfile"],
        },
        "typescript": {
            "extensions": [".ts", ".tsx"],
            "markers": ["tsconfig.json", "package.json"],
        },
        "javascript": {
            "extensions": [".js", ".jsx", ".mjs", ".cjs"],
            "markers": ["package.json", "package-lock.json"],
        },
        "rust": {
            "extensions": [".rs"],
            "markers": ["Cargo.toml", "Cargo.lock"],
        },
        "go": {
            "extensions": [".go"],
            "markers": ["go.mod", "go.sum"],
        },
        "java": {
            "extensions": [".java"],
            "markers": ["pom.xml", "build.gradle", "build.gradle.kts"],
        },
        "cpp": {
            "extensions": [".cpp", ".cc", ".cxx", ".h", ".hpp"],
            "markers": ["CMakeLists.txt", "Makefile"],
        },
        "ruby": {
            "extensions": [".rb"],
            "markers": ["Gemfile", "Rakefile"],
        },
        "php": {
            "extensions": [".php"],
            "markers": ["composer.json"],
        },
        "csharp": {
            "extensions": [".cs"],
            "markers": [".csproj", ".sln"],
        },
        "kotlin": {
            "extensions": [".kt", ".kts"],
            "markers": ["build.gradle.kts"],
        },
        "swift": {
            "extensions": [".swift"],
            "markers": ["Package.swift"],
        },
        "scala": {
            "extensions": [".scala"],
            "markers": ["build.sbt"],
        },
        "lua": {
            "extensions": [".lua"],
            "markers": [],
        },
        "elixir": {
            "extensions": [".ex", ".exs"],
            "markers": ["mix.exs"],
        },
        "haskell": {
            "extensions": [".hs", ".lhs"],
            "markers": ["stack.yaml", "cabal.project"],
        },
    }

    # Common directories to ignore
    IGNORED_DIRS = {
        "node_modules",
        ".git",
        ".venv",
        "venv",
        "env",
        "__pycache__",
        ".pytest_cache",
        "dist",
        "build",
        "target",
        ".idea",
        ".vscode",
        "coverage",
        ".next",
        ".nuxt",
    }

    def __init__(self, project_root: Path, max_languages: int | None = None):
        """Initialize language detector.

        Args:
            project_root: Path to project root directory
            max_languages: Optional limit on number of languages to detect
        """
        self.project_root = Path(project_root)
        self.max_languages = max_languages
        self._gitignore_patterns: list[str] | None = None
        # Load gitignore patterns on init
        self._load_gitignore()

    def detect_languages(self, max_languages: int | None = None) -> dict[str, int]:
        """Detect all programming languages in project.

        Args:
            max_languages: Optional limit on number of languages to return (overrides init value)

        Returns:
            Dict mapping language name to file count, sorted by count descending

        Example:
            >>> detector.detect_languages()
            {'python': 23, 'yaml': 2}
        """
        language_counts: dict[str, int] = {}

        # Scan all files in project
        for file_path in self._scan_project_files():
            # Check each language's extensions
            for language, config in self.LANGUAGE_DEFINITIONS.items():
                if self._is_language_file(file_path, language):
                    language_counts[language] = language_counts.get(language, 0) + 1

        # Sort by count descending
        sorted_languages = dict(sorted(language_counts.items(), key=lambda x: x[1], reverse=True))

        # Apply max limit from parameter or init
        limit = max_languages if max_languages is not None else self.max_languages
        if limit is not None:
            sorted_languages = dict(list(sorted_languages.items())[:limit])

        return sorted_languages

    def detect_languages_with_confidence(self) -> dict[str, int]:
        """Detect languages with confidence scores (file counts).

        Returns:
            Dict mapping language name to file count (confidence score)

        Example:
            >>> detector.detect_languages_with_confidence()
            {'python': 23, 'javascript': 12}
        """
        return self.detect_languages()

    def get_primary_language(self) -> str | None:
        """Identify the primary language of the project.

        Primary language determined by:
        1. Presence of framework markers (package.json, Cargo.toml, etc.)
        2. Language with most files

        Returns:
            Primary language name, or None if no languages detected

        Example:
            >>> detector.get_primary_language()
            'python'
        """
        # First check for framework markers
        for language, config in self.LANGUAGE_DEFINITIONS.items():
            for marker in config.get("markers", []):
                marker_path = self.project_root / marker
                if marker_path.exists():
                    return language

        # Fall back to language with most files
        languages = self.detect_languages()
        if languages:
            return next(iter(languages))  # First key (highest count)

        return None

    def detect_language_frameworks(self, language: str) -> list[str]:
        """Detect frameworks for a specific language.

        Args:
            language: Language identifier (e.g., "python", "typescript")

        Returns:
            List of framework markers found

        Example:
            >>> detector.detect_language_frameworks("python")
            ['pyproject.toml', 'setup.py']
        """
        if language not in self.LANGUAGE_DEFINITIONS:
            return []

        markers_found = []
        markers = self.LANGUAGE_DEFINITIONS[language].get("markers", [])

        for marker in markers:
            marker_path = self.project_root / marker
            if marker_path.exists():
                markers_found.append(marker)

        return markers_found

    def _scan_project_files(self) -> list[Path]:
        """Scan project directory for all files, respecting ignored dirs.

        Returns:
            List of file paths to analyze
        """
        files = []

        for path in self.project_root.rglob("*"):
            # Skip if path is file and not in ignored directory
            if path.is_file():
                # Check if any parent is in ignored dirs
                if not self._should_ignore_path(path):
                    files.append(path)

        return files

    def _should_ignore_path(self, path: Path) -> bool:
        """Check if path should be ignored based on ignored dirs and gitignore.

        Args:
            path: Path to check

        Returns:
            True if path should be ignored
        """
        # Check if any parent directory is in ignored list
        parts = path.relative_to(self.project_root).parts
        for part in parts[:-1]:  # Exclude filename itself
            if part in self.IGNORED_DIRS:
                return True

        # Check gitignore patterns if available
        if self._gitignore_patterns is not None:
            relative_path = str(path.relative_to(self.project_root))
            filename = path.name

            for pattern in self._gitignore_patterns:
                # Handle directory patterns (ending with /)
                if pattern.endswith("/"):
                    dir_pattern = pattern[:-1]
                    # Check if path is inside this directory
                    if dir_pattern in parts:
                        return True
                # Handle wildcard patterns
                elif fnmatch.fnmatch(filename, pattern) or fnmatch.fnmatch(relative_path, pattern):
                    return True

        return False

    def _load_gitignore(self) -> None:
        """Load .gitignore patterns for filtering."""
        gitignore_path = self.project_root / ".gitignore"
        if not gitignore_path.exists():
            self._gitignore_patterns = []
            return

        patterns = []
        with open(gitignore_path) as f:
            for line in f:
                line = line.strip()
                # Skip comments and empty lines
                if line and not line.startswith("#"):
                    patterns.append(line)

        self._gitignore_patterns = patterns

    def _is_language_file(self, file_path: Path, language: str) -> bool:
        """Check if file belongs to specified language.

        Args:
            file_path: Path to file
            language: Language to check

        Returns:
            True if file extension matches language
        """
        if language not in self.LANGUAGE_DEFINITIONS:
            return False

        extensions = self.LANGUAGE_DEFINITIONS[language]["extensions"]
        return file_path.suffix in extensions

    def get_file_extensions_for_language(self, language: str) -> list[str]:
        """Get file extensions for a specific language.

        Args:
            language: Language identifier

        Returns:
            List of file extensions (e.g., ['.py', '.pyi'])
        """
        if language not in self.LANGUAGE_DEFINITIONS:
            return []

        return self.LANGUAGE_DEFINITIONS[language]["extensions"]

    def get_extensions_for_language(self, language: str) -> list[str]:
        """Alias for get_file_extensions_for_language.

        Args:
            language: Language identifier

        Returns:
            List of file extensions
        """
        return self.get_file_extensions_for_language(language)

    def is_language_file(self, file_path: Path, language: str) -> bool:
        """Public API for checking if file is a specific language.

        Args:
            file_path: Path to file
            language: Language to check

        Returns:
            True if file belongs to language
        """
        return self._is_language_file(file_path, language)


__all__ = ["LanguageDetection", "LanguageDetector"]

"""LSP Configurator module for managing .env file configuration.

Handles Layer 3 of the LSP setup: Project configuration via .env file.

Philosophy:
- Single responsibility: .env file management only
- Standard library only (Path, re)
- Atomic file operations for safety
- Self-contained and regeneratable

Public API:
    LSPConfigurator: Main class for LSP configuration management
"""

import re
import shutil
from pathlib import Path
from typing import Any


class LSPConfigurator:
    """Manages LSP configuration in project .env file.

    Handles creating, reading, and updating the .env file to enable/disable
    LSP support in Claude Code.

    Example:
        >>> configurator = LSPConfigurator(Path("/path/to/project"))
        >>> configurator.enable_lsp()
        True
        >>> configurator.is_lsp_enabled()
        True
    """

    LSP_ENABLE_KEY = "ENABLE_LSP_TOOL"
    ENV_FILE_NAME = ".env"

    def __init__(self, project_root: Path):
        """Initialize LSP configurator.

        Args:
            project_root: Path to project root directory
        """
        self.project_root = Path(project_root)
        self.env_file_path = self.project_root / self.ENV_FILE_NAME

    def enable_lsp(self) -> bool:
        """Enable LSP in .env file.

        Creates or updates .env file to set ENABLE_LSP_TOOL=1.
        Preserves existing environment variables.
        Creates automatic backup if .env exists.

        Returns:
            True if successful

        Example:
            >>> configurator.enable_lsp()
            True
        """
        # Backup existing file before modification
        if self.env_file_path.exists():
            self.backup_env_file()

        return self.set_env_variable(self.LSP_ENABLE_KEY, "1")

    def disable_lsp(self) -> bool:
        """Disable LSP in .env file.

        Updates .env file to set ENABLE_LSP_TOOL=0.

        Returns:
            True if successful

        Example:
            >>> configurator.disable_lsp()
            True
        """
        return self.set_env_variable(self.LSP_ENABLE_KEY, "0")

    def is_lsp_enabled(self) -> bool:
        """Check if LSP is currently enabled in .env file.

        Returns:
            True if ENABLE_LSP_TOOL=1, False otherwise

        Example:
            >>> configurator.is_lsp_enabled()
            True
        """
        if not self.env_file_path.exists():
            return False

        env_vars = self.get_all_env_variables()
        value = env_vars.get(self.LSP_ENABLE_KEY, "0")
        return value == "1"

    def get_env_file_path(self) -> Path:
        """Get the path to the .env file.

        Returns:
            Path to .env file

        Example:
            >>> configurator.get_env_file_path()
            PosixPath('/project/.env')
        """
        return self.env_file_path

    def backup_env_file(self) -> Path | None:
        """Create a backup of the current .env file.

        Returns:
            Path to backup file, or None if .env doesn't exist

        Example:
            >>> backup_path = configurator.backup_env_file()
        """
        if not self.env_file_path.exists():
            return None

        # Create backup with .backup suffix (not replacing .env)
        backup_path = self.project_root / (self.ENV_FILE_NAME + ".backup")
        shutil.copy2(self.env_file_path, backup_path)
        return backup_path

    def validate_env_file_syntax(self) -> tuple[bool, list[str]]:
        """Validate .env file syntax.

        Returns:
            Tuple of (is_valid, list_of_errors)

        Example:
            >>> valid, errors = configurator.validate_env_file_syntax()
            >>> if not valid:
            ...     print(f"Errors: {errors}")
        """
        if not self.env_file_path.exists():
            return True, []

        errors = []
        content = self.env_file_path.read_text()

        for line_num, line in enumerate(content.split("\n"), 1):
            line = line.strip()

            # Skip empty lines and comments
            if not line or line.startswith("#"):
                continue

            # Check for valid key=value format
            if "=" not in line:
                errors.append(f"Line {line_num}: Missing '=' in assignment")
                continue

            key, _ = line.split("=", 1)
            if not key or not key.strip():
                errors.append(f"Line {line_num}: Empty variable name")

        return len(errors) == 0, errors

    def get_all_env_variables(self) -> dict[str, str]:
        """Get all environment variables from .env file.

        Returns:
            Dict mapping variable names to values

        Example:
            >>> vars = configurator.get_all_env_variables()
            >>> print(vars['API_KEY'])
        """
        if not self.env_file_path.exists():
            return {}

        env_vars = {}
        content = self.env_file_path.read_text()

        for line in content.split("\n"):
            line = line.strip()

            # Skip empty lines and comments
            if not line or line.startswith("#"):
                continue

            # Parse key=value
            if "=" in line:
                key, value = line.split("=", 1)
                env_vars[key.strip()] = value.strip()

        return env_vars

    def set_env_variable(self, key: str, value: str) -> bool:
        """Set an environment variable in .env file.

        Preserves comments and empty lines. Updates existing key or appends new one.

        Args:
            key: Variable name
            value: Variable value

        Returns:
            True if successful

        Example:
            >>> configurator.set_env_variable("API_KEY", "secret")
            True
        """
        try:
            # Read existing content or start fresh
            if self.env_file_path.exists():
                lines = self.env_file_path.read_text().split("\n")
            else:
                lines = []

            # Look for existing key
            key_pattern = re.compile(f"^{re.escape(key)}\\s*=")
            key_found = False

            for i, line in enumerate(lines):
                if key_pattern.match(line.strip()):
                    # Update existing key
                    lines[i] = f"{key}={value}"
                    key_found = True
                    break

            # Add new key if not found
            if not key_found:
                # Remove trailing empty lines
                while lines and not lines[-1].strip():
                    lines.pop()

                # Add new key
                lines.append(f"{key}={value}")

            # Ensure single newline at end
            content = "\n".join(lines)
            if content and not content.endswith("\n"):
                content += "\n"

            # Write atomically
            self.env_file_path.write_text(content)
            return True

        except OSError:
            # Handle permission errors, disk full, etc.
            return False

    def remove_env_variable(self, key: str) -> bool:
        """Remove an environment variable from .env file.

        Args:
            key: Variable name to remove

        Returns:
            True if successful

        Example:
            >>> configurator.remove_env_variable("OLD_KEY")
            True
        """
        if not self.env_file_path.exists():
            return True  # Already doesn't exist

        try:
            lines = self.env_file_path.read_text().split("\n")
            key_pattern = re.compile(f"^{re.escape(key)}\\s*=")

            # Filter out lines matching the key
            filtered_lines = [line for line in lines if not key_pattern.match(line.strip())]

            # Write back
            content = "\n".join(filtered_lines)
            if content and not content.endswith("\n"):
                content += "\n"

            self.env_file_path.write_text(content)
            return True

        except OSError:
            return False

    def get_lsp_status_summary(self) -> dict[str, Any]:
        """Get summary of LSP configuration status.

        Returns:
            Dict with configuration status information

        Example:
            >>> status = configurator.get_lsp_status_summary()
            >>> print(status['enabled'])
        """
        return {
            "enabled": self.is_lsp_enabled(),
            "env_file_exists": self.env_file_path.exists(),
            "env_file_path": str(self.env_file_path),
            "env_variable_count": len(self.get_all_env_variables()),
        }

    def get_status_summary(self) -> dict[str, Any]:
        """Alias for get_lsp_status_summary.

        Returns:
            Dict with configuration status information
        """
        return self.get_lsp_status_summary()

    def validate_env_syntax(self) -> bool:
        """Validate .env file syntax (simplified return).

        Returns:
            True if valid, False otherwise

        Example:
            >>> configurator.validate_env_syntax()
            True
        """
        is_valid, _ = self.validate_env_file_syntax()
        return is_valid


__all__ = ["LSPConfigurator"]

"""
MCP Configurator for cclsp LSP integration.

Philosophy:
- Configure Claude Code to use cclsp as MCP server
- Generate cclsp.json configuration file
- Add MCP server to Claude Code settings.json
- Zero-BS: Real configuration, no stubs

Public API:
    MCPConfigurator: Configure cclsp MCP server for Claude Code
"""

import json
import subprocess
from pathlib import Path
from typing import Any

__all__ = ["MCPConfigurator", "CCLSPConfig"]


class CCLSPConfig:
    """cclsp.json configuration generator."""

    # Language to LSP server mapping
    LANGUAGE_SERVERS = {
        "python": {"extensions": ["py"], "command": ["pylsp"], "rootDir": "."},
        "javascript": {
            "extensions": ["js", "jsx"],
            "command": ["typescript-language-server", "--stdio"],
            "rootDir": ".",
        },
        "typescript": {
            "extensions": ["ts", "tsx"],
            "command": ["typescript-language-server", "--stdio"],
            "rootDir": ".",
        },
        "rust": {"extensions": ["rs"], "command": ["rust-analyzer"], "rootDir": "."},
        "go": {"extensions": ["go"], "command": ["gopls"], "rootDir": "."},
        "java": {"extensions": ["java"], "command": ["jdtls"], "rootDir": "."},
        "cpp": {
            "extensions": ["cpp", "cxx", "cc", "h", "hpp"],
            "command": ["clangd"],
            "rootDir": ".",
        },
        "c": {"extensions": ["c", "h"], "command": ["clangd"], "rootDir": "."},
        "ruby": {"extensions": ["rb"], "command": ["solargraph", "stdio"], "rootDir": "."},
        "php": {"extensions": ["php"], "command": ["phpactor", "language-server"], "rootDir": "."},
    }

    @classmethod
    def generate_config(cls, languages: list[str]) -> dict[str, Any]:
        """Generate cclsp.json configuration for detected languages."""
        servers = []
        for lang in languages:
            if lang in cls.LANGUAGE_SERVERS:
                servers.append(cls.LANGUAGE_SERVERS[lang])

        return {"servers": servers}


class MCPConfigurator:
    """Configure Claude Code MCP server for cclsp LSP integration."""

    def __init__(self, project_root: Path):
        """Initialize MCP configurator.

        Args:
            project_root: Project root directory
        """
        self.project_root = Path(project_root)
        self.cclsp_config_file = self.project_root / "cclsp.json"
        self.claude_settings = self.project_root / ".claude" / "settings.json"

    def generate_cclsp_config(self, languages: list[str]) -> bool:
        """Generate cclsp.json configuration file.

        Args:
            languages: List of language names to configure

        Returns:
            True if successful
        """
        try:
            config = CCLSPConfig.generate_config(languages)

            # Write cclsp.json
            self.cclsp_config_file.write_text(json.dumps(config, indent=2) + "\n")
            return True
        except OSError:
            return False

    def add_mcp_server_to_claude(self) -> bool:
        """Add cclsp MCP server to Claude Code settings.json.

        Returns:
            True if successful
        """
        try:
            # Ensure .claude directory exists
            self.claude_settings.parent.mkdir(parents=True, exist_ok=True)

            # Load or create settings
            if self.claude_settings.exists():
                settings = json.loads(self.claude_settings.read_text())
            else:
                settings = {}

            # Add mcpServers section if not present
            if "mcpServers" not in settings:
                settings["mcpServers"] = {}

            # Add cclsp server configuration
            settings["mcpServers"]["cclsp"] = {"command": "npx", "args": ["cclsp"]}

            # Write back
            self.claude_settings.write_text(json.dumps(settings, indent=2) + "\n")
            return True

        except (OSError, json.JSONDecodeError):
            return False

    def is_cclsp_configured(self) -> bool:
        """Check if cclsp MCP server is configured.

        Returns:
            True if configured
        """
        if not self.claude_settings.exists():
            return False

        try:
            settings = json.loads(self.claude_settings.read_text())
            return "cclsp" in settings.get("mcpServers", {})
        except (OSError, json.JSONDecodeError):
            return False

    def check_cclsp_available(self) -> bool:
        """Check if cclsp is available via npx.

        Returns:
            True if cclsp can be run
        """
        try:
            result = subprocess.run(["npx", "cclsp", "--version"], capture_output=True, timeout=5)
            # cclsp doesn't have --version, but if it runs, it's available
            return result.returncode in [0, 1]  # May return 1 for unknown flag
        except (FileNotFoundError, subprocess.TimeoutExpired):
            return False

"""
Plugin Manager for Claude Code LSP plugins.

Philosophy:
- Wraps npx cclsp commands for plugin management
- User-guided installation (never auto-installs system binaries)
- Retry logic with exponential backoff
- Clear, actionable error messages

Public API:
    PluginManager: Manages Claude Code LSP plugin lifecycle
    install_plugin: Install a plugin via npx cclsp
    uninstall_plugin: Remove a plugin
    is_plugin_installed: Check if plugin is installed
    list_installed_plugins: Get all installed plugins
"""

import re
import subprocess
import time
from dataclasses import dataclass

__all__ = ["PluginManager", "PluginInstallResult"]


@dataclass
class PluginInstallResult:
    """Result of plugin installation operation."""

    success: bool
    plugin_name: str
    error: str | None = None
    output: str | None = None


class PluginManager:
    """Manages Claude Code LSP plugin installation and lifecycle."""

    def __init__(self, max_retries: int = 3, timeout: int = 120):
        """
        Initialize plugin manager.

        Args:
            max_retries: Maximum retry attempts for failed operations
            timeout: Timeout in seconds for subprocess calls
        """
        self.max_retries = max_retries
        self.timeout = timeout

    def _validate_plugin_name(self, plugin_name: str) -> None:
        """
        Validate plugin name contains only safe characters.

        Args:
            plugin_name: Name to validate

        Raises:
            ValueError: If plugin name contains unsafe characters
        """
        if not re.match(r"^[a-zA-Z0-9_-]+$", plugin_name):
            raise ValueError(f"Invalid plugin name: {plugin_name}")

    def check_npx_available(self) -> bool:
        """
        Check if npx is available on the system.

        Returns:
            True if npx is available, False otherwise
        """
        try:
            result = subprocess.run(["npx", "--version"], capture_output=True, text=True, timeout=5)
            return result.returncode == 0
        except (FileNotFoundError, subprocess.TimeoutExpired):
            return False

    def is_plugin_installed(self, plugin_name: str) -> bool:
        """
        Check if a plugin is installed.

        Args:
            plugin_name: Name of the plugin (e.g., "python", "typescript")

        Returns:
            True if plugin is installed, False otherwise
        """
        self._validate_plugin_name(plugin_name)
        installed = self.list_installed_plugins()
        return plugin_name in installed

    def list_installed_plugins(self) -> list[str]:
        """
        List all installed Claude Code LSP plugins.

        Returns:
            List of installed plugin names
        """
        if not self.check_npx_available():
            return []

        try:
            result = subprocess.run(
                ["npx", "cclsp", "list"], capture_output=True, text=True, timeout=self.timeout
            )

            if result.returncode == 0:
                # Parse plugin list from stdout (one per line)
                plugins = [
                    line.strip() for line in result.stdout.strip().split("\n") if line.strip()
                ]
                return plugins
            return []
        except (subprocess.TimeoutExpired, Exception):
            return []

    def install_plugin(self, plugin_name: str, dry_run: bool = False) -> bool:
        """
        Install a Claude Code LSP plugin via npx cclsp.

        Args:
            plugin_name: Name of plugin to install (e.g., "python")
            dry_run: If True, don't actually install, just check

        Returns:
            True if installation successful, False otherwise
        """
        self._validate_plugin_name(plugin_name)

        if not self.check_npx_available():
            return False

        if dry_run:
            # Just check if plugin is already installed (validation happens in is_plugin_installed)
            return not self.is_plugin_installed(plugin_name)

        # Check if already installed
        if self.is_plugin_installed(plugin_name):
            return True

        # Install with retry logic
        for attempt in range(self.max_retries):
            try:
                result = subprocess.run(
                    ["npx", "cclsp", "install", plugin_name],
                    capture_output=True,
                    text=True,
                    timeout=self.timeout,
                )

                if result.returncode == 0:
                    return True

                # Retry on failure (except last attempt)
                if attempt < self.max_retries - 1:
                    time.sleep(2**attempt)  # Exponential backoff

            except subprocess.TimeoutExpired:
                if attempt < self.max_retries - 1:
                    time.sleep(2**attempt)
                    continue
                return False

        return False

    def install_multiple_plugins(
        self, plugin_names: list[str], dry_run: bool = False
    ) -> tuple[list[str], list[str]]:
        """
        Install multiple plugins.

        Args:
            plugin_names: List of plugin names to install
            dry_run: If True, don't actually install

        Returns:
            Tuple of (successful_plugins, failed_plugins)
        """
        successful = []
        failed = []

        for plugin in plugin_names:
            if self.install_plugin(plugin, dry_run=dry_run):
                successful.append(plugin)
            else:
                failed.append(plugin)

        return successful, failed

    def uninstall_plugin(self, plugin_name: str) -> bool:
        """
        Uninstall a Claude Code LSP plugin.

        Args:
            plugin_name: Name of plugin to uninstall

        Returns:
            True if uninstallation successful, False otherwise
        """
        self._validate_plugin_name(plugin_name)

        if not self.check_npx_available():
            return False

        # Check if plugin is installed (validation happens in is_plugin_installed)
        if not self.is_plugin_installed(plugin_name):
            return True  # Already uninstalled

        try:
            result = subprocess.run(
                ["npx", "cclsp", "uninstall", plugin_name],
                capture_output=True,
                text=True,
                timeout=self.timeout,
            )

            return result.returncode == 0
        except (subprocess.TimeoutExpired, Exception):
            return False

    def get_plugin_info(self, plugin_name: str) -> dict | None:
        """
        Get information about a plugin.

        Args:
            plugin_name: Name of the plugin

        Returns:
            Dict with plugin info, or None if not found
        """
        if not self.is_plugin_installed(plugin_name):
            return None

        return {"name": plugin_name, "installed": True, "source": "npx cclsp"}

    def update_plugin(self, plugin_name: str) -> bool:
        """
        Update a plugin to latest version.

        Args:
            plugin_name: Name of plugin to update

        Returns:
            True if update successful, False otherwise
        """
        # Uninstall then reinstall to get latest version
        if self.uninstall_plugin(plugin_name):
            return self.install_plugin(plugin_name)
        return False

"""
Status Tracker for LSP three-layer architecture.

Philosophy:
- Checks all three layers: System binaries, Claude plugins, .env config
- Generates actionable user guidance for missing components
- Platform-specific installation instructions
- Zero-BS: Real checks, no fake status

Public API:
    StatusTracker: Tracks LSP configuration status across three layers
    check_layer_1: Check system LSP binaries
    check_layer_2: Check Claude Code plugins
    check_layer_3: Check .env configuration
    get_full_status: Get complete status across all layers
    generate_user_guidance: Create actionable setup instructions
"""

import platform
import shutil
from dataclasses import dataclass
from pathlib import Path
from typing import Any

__all__ = ["StatusTracker", "LayerStatus"]


@dataclass
class LayerStatus:
    """Status for a single layer."""

    installed: bool
    details: str | None = None
    install_guide: str | None = None


class StatusTracker:
    """Tracks LSP configuration status across three layers."""

    # Mapping of languages to system binaries
    LANGUAGE_TO_BINARY = {
        "python": "pyright",
        "typescript": "vtsls",
        "javascript": "vtsls",
        "rust": "rust-analyzer",
        "go": "gopls",
        "java": "jdtls",
        "cpp": "clangd",
        "c": "clangd",
        "ruby": "ruby-lsp",
        "php": "phpactor",
        "csharp": "omnisharp",
        "kotlin": "kotlin-language-server",
        "swift": "sourcekit-lsp",
        "scala": "metals",
        "lua": "lua-language-server",
        "elixir": "elixir-ls",
        "haskell": "haskell-language-server",
    }

    # Platform-specific install commands
    INSTALL_COMMANDS = {
        "python": {
            "darwin": "npm install -g pyright",
            "linux": "npm install -g pyright",
        },
        "typescript": {
            "darwin": "npm install -g @vtsls/language-server",
            "linux": "npm install -g @vtsls/language-server",
        },
        "javascript": {
            "darwin": "npm install -g @vtsls/language-server",
            "linux": "npm install -g @vtsls/language-server",
        },
        "rust": {
            "darwin": "rustup component add rust-analyzer",
            "linux": "rustup component add rust-analyzer",
        },
        "go": {
            "darwin": "go install golang.org/x/tools/gopls@latest",
            "linux": "go install golang.org/x/tools/gopls@latest",
        },
        "java": {
            "darwin": "brew install jdtls",
            "linux": "Download from eclipse.org/jdtls",
        },
        "cpp": {
            "darwin": "brew install llvm",
            "linux": "sudo apt install clangd",
        },
        "c": {
            "darwin": "brew install llvm",
            "linux": "sudo apt install clangd",
        },
        "ruby": {
            "darwin": "gem install ruby-lsp",
            "linux": "gem install ruby-lsp",
        },
        "php": {
            "darwin": "composer global require phpactor/phpactor",
            "linux": "composer global require phpactor/phpactor",
        },
    }

    def __init__(self, project_root: Path, languages: list[str]):
        """
        Initialize status tracker.

        Args:
            project_root: Path to project root directory
            languages: List of language names to track
        """
        self.project_root = Path(project_root)
        self.languages = languages
        self.env_file = self.project_root / ".env"

    def check_layer_1(self) -> dict[str, dict]:
        """
        Check Layer 1: System LSP binaries.

        Returns:
            Dict mapping language -> status info
        """
        status = {}

        for lang in self.languages:
            binary = self.LANGUAGE_TO_BINARY.get(lang)
            if not binary:
                status[lang] = {"installed": False, "error": f"Unknown language: {lang}"}
                continue

            # Check if binary exists
            binary_path = shutil.which(binary)
            is_installed = binary_path is not None

            status[lang] = {
                "installed": is_installed,
                "binary": binary,
                "path": binary_path if is_installed else None,
            }

            # Add install guide if missing
            if not is_installed:
                status[lang]["install_guide"] = self._get_install_command(lang)

        return status

    def check_layer_2(self) -> dict[str, dict]:
        """
        Check Layer 2: Claude Code plugins.

        Returns:
            Dict mapping language -> plugin status
        """
        from .plugin_manager import PluginManager

        manager = PluginManager()
        installed_plugins = manager.list_installed_plugins()

        status = {}
        for lang in self.languages:
            is_installed = lang in installed_plugins

            status[lang] = {
                "installed": is_installed,
                "plugin_name": lang,
            }

            if not is_installed:
                status[lang]["install_guide"] = f"npx cclsp install {lang}"

        return status

    def check_layer_3(self) -> dict[str, Any]:
        """
        Check Layer 3: .env configuration.

        Returns:
            Dict with enabled status and config details
        """
        if not self.env_file.exists():
            return {
                "enabled": False,
                "env_file_exists": False,
                "install_guide": "Run: echo 'ENABLE_LSP_TOOL=1' >> .env",
            }

        # Check if ENABLE_LSP_TOOL=1 is set
        content = self.env_file.read_text()
        enabled = "ENABLE_LSP_TOOL=1" in content

        return {
            "enabled": enabled,
            "env_file_exists": True,
            "path": str(self.env_file),
            "install_guide": "Add 'ENABLE_LSP_TOOL=1' to .env file" if not enabled else None,
        }

    def get_full_status(self) -> dict[str, Any]:
        """
        Get complete status across all three layers.

        Returns:
            Dict with status for all layers plus overall readiness
        """
        layer_1 = self.check_layer_1()
        layer_2 = self.check_layer_2()
        layer_3 = self.check_layer_3()

        # Check if all layers are ready
        all_layer_1_ready = all(lang_status["installed"] for lang_status in layer_1.values())
        all_layer_2_ready = all(lang_status["installed"] for lang_status in layer_2.values())
        layer_3_ready = layer_3["enabled"]

        overall_ready = all_layer_1_ready and all_layer_2_ready and layer_3_ready

        return {
            "layer_1": layer_1,
            "layer_2": layer_2,
            "layer_3": layer_3,
            "overall_ready": overall_ready,
        }

    def generate_user_guidance(self) -> str:
        """
        Generate actionable setup guidance based on current status.

        Returns:
            Formatted string with setup instructions
        """
        status = self.get_full_status()

        if status["overall_ready"]:
            return "✅ All LSP layers configured! No action needed."

        guidance_parts = ["LSP Setup Status:\n"]

        # Layer 1 guidance
        layer_1_issues = [
            (lang, info) for lang, info in status["layer_1"].items() if not info["installed"]
        ]

        if layer_1_issues:
            guidance_parts.append("\n🔴 Layer 1: Missing System LSP Binaries")
            for lang, info in layer_1_issues:
                guidance_parts.append(f"  • {lang}: {info.get('install_guide', 'See docs')}")

        # Layer 2 guidance
        layer_2_issues = [
            (lang, info) for lang, info in status["layer_2"].items() if not info["installed"]
        ]

        if layer_2_issues:
            guidance_parts.append("\n🟡 Layer 2: Missing Claude Code Plugins")
            for lang, info in layer_2_issues:
                guidance_parts.append(f"  • {lang}: {info.get('install_guide', 'See docs')}")

        # Layer 3 guidance
        if not status["layer_3"]["enabled"]:
            guidance_parts.append("\n🟠 Layer 3: .env Configuration Missing")
            guidance_parts.append(f"  • {status['layer_3'].get('install_guide', 'See docs')}")

        return "\n".join(guidance_parts)

    def _get_install_command(self, language: str) -> str:
        """Get platform-specific install command for a language."""
        system = platform.system().lower()
        if system == "darwin":
            platform_key = "darwin"
        else:
            platform_key = "linux"

        commands = self.INSTALL_COMMANDS.get(language, {})
        return commands.get(platform_key, f"Install {language} LSP server manually")

    def get_setup_progress(self) -> dict[str, Any]:
        """
        Get setup progress metrics.

        Returns:
            Dict with progress percentages for each layer
        """
        status = self.get_full_status()

        total_langs = len(self.languages)
        if total_langs == 0:
            return {
                "layer_1_progress": 100,
                "layer_2_progress": 100,
                "layer_3_progress": 100,
                "overall_progress": 100,
            }

        # Layer 1 progress
        layer_1_installed = sum(1 for info in status["layer_1"].values() if info["installed"])
        layer_1_progress = (layer_1_installed / total_langs) * 100

        # Layer 2 progress
        layer_2_installed = sum(1 for info in status["layer_2"].values() if info["installed"])
        layer_2_progress = (layer_2_installed / total_langs) * 100

        # Layer 3 progress (binary: 0 or 100)
        layer_3_progress = 100 if status["layer_3"]["enabled"] else 0

        # Overall progress (weighted average)
        overall_progress = layer_1_progress * 0.4 + layer_2_progress * 0.4 + layer_3_progress * 0.2

        return {
            "layer_1_progress": round(layer_1_progress, 1),
            "layer_2_progress": round(layer_2_progress, 1),
            "layer_3_progress": round(layer_3_progress, 1),
            "overall_progress": round(overall_progress, 1),
        }

    def get_next_action(self) -> str | None:
        """Get the next recommended action for setup."""
        status = self.get_full_status()
        if status["overall_ready"]:
            return None

        # Priority: Layer 3 -> Layer 1 -> Layer 2
        if not status["layer_3"]["enabled"]:
            return status["layer_3"].get("install_guide", "Configure .env")

        for lang, info in status["layer_1"].items():
            if not info["installed"]:
                return info.get("install_guide", f"Install {lang} LSP binary")

        for lang, info in status["layer_2"].items():
            if not info["installed"]:
                return info.get("install_guide", f"Install {lang} plugin")

        return None

    def get_missing_components(self) -> list[str]:
        """Get list of missing components."""
        status = self.get_full_status()
        missing = []

        for lang, info in status["layer_1"].items():
            if not info["installed"]:
                missing.append(f"Layer 1: {lang} binary")

        for lang, info in status["layer_2"].items():
            if not info["installed"]:
                missing.append(f"Layer 2: {lang} plugin")

        if not status["layer_3"]["enabled"]:
            missing.append("Layer 3: .env configuration")

        return missing

    def get_completion_percentage(self) -> float:
        """Get overall completion percentage."""
        progress = self.get_setup_progress()
        return progress["overall_progress"]

    def validate_layer_dependencies(self) -> dict[str, bool]:
        """Validate dependencies between layers."""
        status = self.get_full_status()
        return {
            "layer_2_requires_layer_1": True,  # Plugins need binaries
            "layer_3_independent": True,  # .env is independent
        }

    def export_status_report(self, format: str = "text") -> str:
        """Export status report in specified format."""
        if format == "json":
            import json

            return json.dumps(self.get_full_status(), indent=2)
        return self.generate_user_guidance()

    def get_troubleshooting_tips(self) -> list[str]:
        """Get troubleshooting tips based on current status."""
        status = self.get_full_status()
        tips = []

        if not status["overall_ready"]:
            tips.append("Check that npx is installed: npx --version")
            tips.append("Verify PATH includes LSP binaries: echo $PATH")
            tips.append("Check .env file syntax")

        return tips

    def get_platform_requirements(self) -> dict[str, list[str]]:
        """Get platform-specific requirements."""
        system = platform.system().lower()
        platform_name = "darwin" if system == "darwin" else "linux"

        requirements = {}
        for lang in self.languages:
            cmd = self._get_install_command(lang)
            requirements[lang] = [cmd]

        return requirements

    def get_install_commands(self) -> dict[str, str]:
        """Get install commands for all languages."""
        commands = {}
        for lang in self.languages:
            commands[lang] = self._get_install_command(lang)
        return commands

    def estimate_setup_time(self) -> int:
        """Estimate setup time in minutes."""
        status = self.get_full_status()
        missing_count = len(self.get_missing_components())

        # Rough estimate: 2 minutes per missing component
        return missing_count * 2

"""
Test suite for LSP Auto-Configuration system.

Testing pyramid:
- 60% Unit tests (fast, heavily mocked)
- 30% Integration tests (multiple components)
- 10% E2E tests (complete workflows)

Target ratio: 3:1 to 5:1 (test lines : implementation lines)
"""

__all__ = []

"""
Pytest fixtures for LSP Auto-Configuration tests.

Provides common test fixtures and utilities following TDD principles.
"""

from pathlib import Path
from unittest.mock import MagicMock, Mock

import pytest


@pytest.fixture
def mock_project_root(tmp_path: Path) -> Path:
    """Create a temporary project root directory."""
    return tmp_path


@pytest.fixture
def mock_env_file(mock_project_root: Path) -> Path:
    """Create a mock .env file path."""
    env_file = mock_project_root / ".env"
    return env_file


@pytest.fixture
def sample_python_files(mock_project_root: Path) -> list[Path]:
    """Create sample Python files for language detection."""
    files = []
    for name in ["main.py", "utils.py", "tests/test_main.py"]:
        file_path = mock_project_root / name
        file_path.parent.mkdir(parents=True, exist_ok=True)
        file_path.write_text("# Python code")
        files.append(file_path)
    return files


@pytest.fixture
def sample_typescript_files(mock_project_root: Path) -> list[Path]:
    """Create sample TypeScript files for language detection."""
    files = []
    for name in ["index.ts", "utils.ts", "tests/test.ts"]:
        file_path = mock_project_root / name
        file_path.parent.mkdir(parents=True, exist_ok=True)
        file_path.write_text("// TypeScript code")
        files.append(file_path)
    return files


@pytest.fixture
def sample_mixed_language_files(mock_project_root: Path) -> dict[str, list[Path]]:
    """Create a project with multiple languages."""
    files = {
        "python": [],
        "typescript": [],
        "javascript": [],
        "rust": [],
    }

    # Python files
    for name in ["main.py", "utils.py"]:
        file_path = mock_project_root / name
        file_path.write_text("# Python")
        files["python"].append(file_path)

    # TypeScript files
    for name in ["index.ts", "types.ts"]:
        file_path = mock_project_root / name
        file_path.write_text("// TypeScript")
        files["typescript"].append(file_path)

    # JavaScript files
    for name in ["app.js", "config.js"]:
        file_path = mock_project_root / name
        file_path.write_text("// JavaScript")
        files["javascript"].append(file_path)

    # Rust files
    for name in ["main.rs", "lib.rs"]:
        file_path = mock_project_root / "src" / name
        file_path.parent.mkdir(parents=True, exist_ok=True)
        file_path.write_text("// Rust")
        files["rust"].append(file_path)

    return files


@pytest.fixture
def mock_subprocess_run():
    """Mock subprocess.run for external command testing."""
    mock = MagicMock()
    mock.return_value.returncode = 0
    mock.return_value.stdout = ""
    mock.return_value.stderr = ""
    return mock


@pytest.fixture
def mock_shutil_which():
    """Mock shutil.which for binary detection."""
    return MagicMock()


@pytest.fixture
def installed_lsp_binaries() -> dict[str, str]:
    """Simulate installed LSP binaries."""
    return {
        "pyright": "/usr/local/bin/pyright",
        "typescript-language-server": "/usr/local/bin/typescript-language-server",
        "rust-analyzer": "/usr/local/bin/rust-analyzer",
    }


@pytest.fixture
def missing_lsp_binaries() -> dict[str, None]:
    """Simulate missing LSP binaries."""
    return {
        "pyright": None,
        "typescript-language-server": None,
        "rust-analyzer": None,
    }


@pytest.fixture
def mock_npx_cclsp_success(mock_subprocess_run):
    """Mock successful npx cclsp install."""

    def mock_run(cmd, *args, **kwargs):
        result = Mock()
        if "cclsp" in cmd and "list" in cmd:
            result.returncode = 0
            result.stdout = "python\ntypescript\nrust\n"
            result.stderr = ""
        elif "cclsp" in cmd and "install" in cmd:
            result.returncode = 0
            result.stdout = "Successfully installed plugin"
            result.stderr = ""
        else:
            result.returncode = 0
            result.stdout = ""
            result.stderr = ""
        return result

    mock_subprocess_run.side_effect = mock_run
    return mock_subprocess_run


@pytest.fixture
def mock_npx_cclsp_failure(mock_subprocess_run):
    """Mock failed npx cclsp install."""

    def mock_run(cmd, *args, **kwargs):
        result = Mock()
        if "cclsp" in cmd:
            result.returncode = 1
            result.stdout = ""
            result.stderr = "Failed to install plugin"
        else:
            result.returncode = 0
            result.stdout = ""
            result.stderr = ""
        return result

    mock_subprocess_run.side_effect = mock_run
    return mock_subprocess_run


@pytest.fixture
def language_to_lsp_mapping() -> dict[str, dict[str, str]]:
    """Standard mapping of languages to LSP servers."""
    return {
        "python": {
            "binary": "pyright",
            "plugin": "python",
            "install_guide": "npm install -g pyright",
        },
        "typescript": {
            "binary": "typescript-language-server",
            "plugin": "typescript",
            "install_guide": "npm install -g typescript-language-server",
        },
        "javascript": {
            "binary": "typescript-language-server",
            "plugin": "typescript",
            "install_guide": "npm install -g typescript-language-server",
        },
        "rust": {
            "binary": "rust-analyzer",
            "plugin": "rust",
            "install_guide": "rustup component add rust-analyzer",
        },
        "go": {
            "binary": "gopls",
            "plugin": "go",
            "install_guide": "go install golang.org/x/tools/gopls@latest",
        },
    }


@pytest.fixture
def mock_platform_system():
    """Mock platform.system() for platform-specific tests."""
    return MagicMock(return_value="Darwin")  # Default to macOS

"""
End-to-end tests for LSP Auto-Configuration (10% - E2E Tests)

Tests complete user workflows from start to finish.
All tests should FAIL initially (TDD red phase).
"""

from unittest.mock import MagicMock, patch


class TestCompleteSetupWorkflows:
    """E2E tests for complete setup workflows."""

    def test_first_time_user_full_auto_setup(
        self,
        mock_project_root,
        sample_python_files,
        installed_lsp_binaries,
        mock_npx_cclsp_success,
        mock_env_file,
    ):
        """
        E2E: First-time user with Python project, LSP binaries installed.
        Expected: Full auto-setup completes all 3 layers.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.lsp_configurator import LSPConfigurator
        from lsp_setup.plugin_manager import PluginManager
        from lsp_setup.status_tracker import StatusTracker

        # User starts with Python project, pyright installed
        with patch("shutil.which", side_effect=lambda x: installed_lsp_binaries.get(x)):
            with patch("subprocess.run", mock_npx_cclsp_success):
                # Simulate user running the skill
                detector = LanguageDetector(mock_project_root)
                languages = detector.detect_languages()

                # Auto-setup flow
                manager = PluginManager()
                manager.install_plugins(languages)

                configurator = LSPConfigurator(mock_project_root)
                configurator.enable_lsp()

                # Verify final state
                tracker = StatusTracker(mock_project_root, languages)
                status = tracker.get_full_status()

                assert status["overall_ready"] is True
                assert configurator.is_lsp_enabled() is True

    def test_first_time_user_no_binaries_manual_setup(self, mock_project_root, sample_python_files):
        """
        E2E: First-time user with Python project, no LSP binaries installed.
        Expected: Generate user guidance for manual installation.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.status_tracker import StatusTracker

        # User starts with Python project, no binaries
        with patch("shutil.which", return_value=None):
            with patch("subprocess.run") as mock_run:
                mock_run.return_value.stdout = ""

                # Simulate user running the skill
                detector = LanguageDetector(mock_project_root)
                languages = detector.detect_languages()

                tracker = StatusTracker(mock_project_root, languages)
                guidance = tracker.generate_user_guidance()

                # Verify guidance includes all necessary steps
                assert "Layer 1" in guidance
                assert "pyright" in guidance.lower()
                assert "npm install" in guidance.lower() or "pip install" in guidance.lower()
                assert "npx cclsp install" in guidance
                assert "ENABLE_LSP_TOOL=1" in guidance

    def test_multi_language_project_full_setup(
        self,
        mock_project_root,
        sample_mixed_language_files,
        language_to_lsp_mapping,
        mock_npx_cclsp_success,
        mock_env_file,
    ):
        """
        E2E: Multi-language project (Python, TypeScript, Rust, JavaScript).
        Expected: Setup all detected languages.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.lsp_configurator import LSPConfigurator
        from lsp_setup.plugin_manager import PluginManager
        from lsp_setup.status_tracker import StatusTracker

        # Mock all binaries installed
        def mock_which(binary):
            binary_map = {
                "pyright": "/usr/local/bin/pyright",
                "typescript-language-server": "/usr/local/bin/typescript-language-server",
                "rust-analyzer": "/usr/local/bin/rust-analyzer",
            }
            return binary_map.get(binary)

        with patch("shutil.which", side_effect=mock_which):
            with patch("subprocess.run", mock_npx_cclsp_success):
                # Detect all languages
                detector = LanguageDetector(mock_project_root)
                languages = detector.detect_languages()

                assert len(languages) == 4  # Python, TS, JS, Rust

                # Install plugins for all
                manager = PluginManager()
                results = manager.install_plugins(languages)

                for lang in languages:
                    assert results[lang] is True

                # Configure .env
                configurator = LSPConfigurator(mock_project_root)
                configurator.enable_lsp()

                # Verify all languages ready
                tracker = StatusTracker(mock_project_root, languages)
                status = tracker.get_full_status()

                assert status["overall_ready"] is True

    def test_existing_user_adding_new_language(
        self,
        mock_project_root,
        sample_python_files,
        installed_lsp_binaries,
        mock_npx_cclsp_success,
        mock_env_file,
    ):
        """
        E2E: Existing user with Python setup, adds TypeScript files.
        Expected: Detect new language and extend setup.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.plugin_manager import PluginManager
        from lsp_setup.status_tracker import StatusTracker

        # Initial setup: Python already configured
        mock_env_file.write_text("ENABLE_LSP_TOOL=1\n")

        # User adds TypeScript files
        (mock_project_root / "index.ts").write_text("// TypeScript")
        (mock_project_root / "utils.ts").write_text("// TypeScript")

        with patch("shutil.which", side_effect=lambda x: installed_lsp_binaries.get(x)):
            with patch("subprocess.run") as mock_run:
                # Mock: Python plugin already installed, TS not installed
                def mock_run_fn(cmd, *args, **kwargs):
                    result = MagicMock()
                    if "list" in cmd:
                        result.stdout = "python\n"  # Only Python installed
                    elif "install" in cmd and "typescript" in cmd:
                        result.returncode = 0
                        result.stdout = "Installed typescript"
                    else:
                        result.returncode = 0
                        result.stdout = ""
                    return result

                mock_run.side_effect = mock_run_fn

                # Detect languages (should find Python + TypeScript)
                detector = LanguageDetector(mock_project_root)
                languages = detector.detect_languages()

                assert "python" in languages
                assert "typescript" in languages

                # Check status
                tracker = StatusTracker(mock_project_root, languages)
                missing = tracker.get_missing_components()

                # TypeScript plugin should be missing
                assert "typescript" in missing["plugins"]

                # Install TypeScript plugin
                manager = PluginManager()
                result = manager.install_plugin("typescript")
                assert result is True

    def test_user_disables_then_re_enables_lsp(
        self, mock_project_root, sample_python_files, mock_env_file
    ):
        """
        E2E: User disables LSP, then re-enables it later.
        Expected: .env updates correctly both times.
        """
        from lsp_setup.lsp_configurator import LSPConfigurator

        configurator = LSPConfigurator(mock_project_root)

        # Enable LSP
        configurator.enable_lsp()
        assert configurator.is_lsp_enabled() is True

        # Disable LSP
        configurator.disable_lsp()
        assert configurator.is_lsp_enabled() is False

        # Re-enable LSP
        configurator.enable_lsp()
        assert configurator.is_lsp_enabled() is True

    def test_troubleshooting_workflow(
        self, mock_project_root, sample_python_files, mock_subprocess_run
    ):
        """
        E2E: User reports LSP not working, troubleshooting flow.
        Expected: Identify specific layer that's broken.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.status_tracker import StatusTracker

        # Scenario: Layer 1 OK, Layer 2 broken, Layer 3 OK
        with patch("shutil.which", return_value="/usr/local/bin/pyright"):
            mock_subprocess_run.return_value.stdout = ""  # No plugins installed
            (mock_project_root / ".env").write_text("ENABLE_LSP_TOOL=1\n")

            with patch("subprocess.run", mock_subprocess_run):
                detector = LanguageDetector(mock_project_root)
                languages = detector.detect_languages()

                tracker = StatusTracker(mock_project_root, languages)
                issues = tracker.validate_layer_dependencies()

                # Should identify Layer 2 as the problem
                assert len(issues) > 0

                next_action = tracker.get_next_action()
                assert "plugin" in next_action.lower()


class TestEdgeCases:
    """E2E tests for edge cases and unusual scenarios."""

    def test_empty_project_no_languages(self, mock_project_root):
        """
        E2E: Empty project with no source files.
        Expected: Graceful handling with appropriate message.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.status_tracker import StatusTracker

        detector = LanguageDetector(mock_project_root)
        languages = detector.detect_languages()

        assert len(languages) == 0

        # Status tracker should handle empty language list
        tracker = StatusTracker(mock_project_root, languages)
        guidance = tracker.generate_user_guidance()

        assert "no languages detected" in guidance.lower() or "empty project" in guidance.lower()

    def test_unsupported_language_project(self, mock_project_root):
        """
        E2E: Project with unsupported language files only.
        Expected: Report no supported languages found.
        """
        from lsp_setup.language_detector import LanguageDetector

        # Create files for unsupported language (e.g., .txt, .md only)
        (mock_project_root / "README.md").write_text("# Project")
        (mock_project_root / "data.txt").write_text("Some data")

        detector = LanguageDetector(mock_project_root)
        languages = detector.detect_languages()

        assert len(languages) == 0

    def test_large_project_with_many_files(self, mock_project_root):
        """
        E2E: Large project with 100+ files across multiple languages.
        Expected: Efficient detection and setup.
        """
        from lsp_setup.language_detector import LanguageDetector

        # Create 50 Python files
        for i in range(50):
            (mock_project_root / f"file{i}.py").write_text("# Python")

        # Create 30 TypeScript files
        for i in range(30):
            (mock_project_root / f"file{i}.ts").write_text("// TypeScript")

        # Create 20 JavaScript files
        for i in range(20):
            (mock_project_root / f"file{i}.js").write_text("// JavaScript")

        detector = LanguageDetector(mock_project_root)
        languages_with_scores = detector.detect_languages_with_confidence()

        assert languages_with_scores["python"] == 50
        assert languages_with_scores["typescript"] == 30
        assert languages_with_scores["javascript"] == 20

    def test_project_with_gitignore_exclusions(self, mock_project_root):
        """
        E2E: Project with .gitignore excluding certain directories.
        Expected: Respect .gitignore when detecting languages.
        """
        from lsp_setup.language_detector import LanguageDetector

        # Create .gitignore
        (mock_project_root / ".gitignore").write_text("build/\n*.tmp\n")

        # Create files (some should be ignored)
        (mock_project_root / "main.py").write_text("# Python")
        (mock_project_root / "build").mkdir()
        (mock_project_root / "build" / "generated.py").write_text("# Should ignore")
        (mock_project_root / "temp.tmp").write_text("# Should ignore")

        detector = LanguageDetector(mock_project_root)
        languages_with_scores = detector.detect_languages_with_confidence()

        # Should only count main.py
        assert languages_with_scores.get("python", 0) == 1


class TestPlatformSpecific:
    """E2E tests for platform-specific scenarios."""

    def test_macos_setup_workflow(
        self,
        mock_project_root,
        sample_python_files,
        mock_platform_system,
        installed_lsp_binaries,
    ):
        """
        E2E: Setup workflow on macOS.
        Expected: macOS-specific installation guidance.
        """
        from lsp_setup.status_tracker import StatusTracker

        mock_platform_system.return_value = "Darwin"

        with patch("platform.system", mock_platform_system):
            with patch("shutil.which", return_value=None):
                tracker = StatusTracker(mock_project_root, ["python"])
                guidance = tracker.generate_user_guidance()

                # Should include macOS-specific commands (Homebrew)
                assert "brew" in guidance.lower() or "macos" in guidance.lower()

    def test_linux_setup_workflow(
        self, mock_project_root, sample_python_files, mock_platform_system
    ):
        """
        E2E: Setup workflow on Linux.
        Expected: Linux-specific installation guidance.
        """
        from lsp_setup.status_tracker import StatusTracker

        mock_platform_system.return_value = "Linux"

        with patch("platform.system", mock_platform_system):
            with patch("shutil.which", return_value=None):
                tracker = StatusTracker(mock_project_root, ["python"])
                guidance = tracker.generate_user_guidance()

                # Should include Linux-specific commands (apt/dnf)
                assert (
                    "apt" in guidance.lower()
                    or "dnf" in guidance.lower()
                    or "linux" in guidance.lower()
                )


class TestUserExperience:
    """E2E tests for user experience scenarios."""

    def test_clear_progress_reporting(
        self,
        mock_project_root,
        sample_python_files,
        installed_lsp_binaries,
        mock_npx_cclsp_success,
    ):
        """
        E2E: User sees clear progress through setup.
        Expected: Percentage completion updates correctly.
        """
        from lsp_setup.language_detector import LanguageDetector
        from lsp_setup.lsp_configurator import LSPConfigurator
        from lsp_setup.plugin_manager import PluginManager
        from lsp_setup.status_tracker import StatusTracker

        detector = LanguageDetector(mock_project_root)
        languages = detector.detect_languages()

        with patch("shutil.which", side_effect=lambda x: installed_lsp_binaries.get(x)):
            with patch("subprocess.run", mock_npx_cclsp_success):
                tracker = StatusTracker(mock_project_root, languages)

                # Initial progress
                progress_0 = tracker.get_completion_percentage()

                # After plugin install
                manager = PluginManager()
                manager.install_plugins(languages)
                progress_1 = tracker.get_completion_percentage()

                # After .env config
                configurator = LSPConfigurator(mock_project_root)
                configurator.enable_lsp()
                progress_2 = tracker.get_completion_percentage()

                # Progress should increase
                assert progress_1 > progress_0
                assert progress_2 > progress_1
                assert progress_2 == 100

    def test_helpful_error_messages(self, mock_project_root, sample_python_files):
        """
        E2E: User encounters errors, gets helpful error messages.
        Expected: Clear, actionable error messages.
        """
        from lsp_setup.plugin_manager import PluginManager

        with patch("shutil.which", return_value=None):
            manager = PluginManager()

            # npx not available
            is_available = manager.is_npx_available()
            assert is_available is False

            # Should provide helpful guidance
            # (In real implementation, this would be in error messages)