"""Swift language plugin implementation with advanced features."""

from __future__ import annotations

import logging
import re
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional, Set, Tuple

from ...plugin_base import IndexShard, SearchOpts, SearchResult
from ...storage.sqlite_store import SQLiteStore
from ..specialized_plugin_base import (
    BuildDependency,
    CrossFileReference,
    IBuildSystemIntegration,
    ICrossFileAnalyzer,
    IImportResolver,
    ImportInfo,
    ITypeAnalyzer,
    SpecializedPluginBase,
    TypeInfo,
)
from .module_analyzer import SwiftModuleAnalyzer
from .objc_bridge import ObjectiveCBridge
from .protocol_checker import SwiftProtocolChecker

logger = logging.getLogger(__name__)

# Swift-specific language configuration
SWIFT_CONFIG = {
    "code": "swift",
    "name": "Swift",
    "extensions": [".swift"],
    "symbols": [
        "class_declaration",
        "struct_declaration",
        "enum_declaration",
        "protocol_declaration",
        "extension_declaration",
        "function_declaration",
        "init_declaration",
        "deinit_declaration",
        "property_declaration",
        "subscript_declaration",
        "operator_declaration",
        "precedence_group_declaration",
        "associated_type_declaration",
        "import_declaration",
    ],
    "query": """
        ; Classes
        (class_declaration name: (type_identifier) @class) @class_def
        
        ; Structures
        (struct_declaration name: (type_identifier) @struct) @struct_def
        
        ; Enumerations
        (enum_declaration name: (type_identifier) @enum) @enum_def
        
        ; Protocols
        (protocol_declaration name: (type_identifier) @protocol) @protocol_def
        
        ; Extensions
        (extension_declaration type: (type_identifier) @extension) @extension_def
        
        ; Functions
        (function_declaration name: (simple_identifier) @function) @function_def
        
        ; Initializers
        (init_declaration) @init @init_def
        
        ; Deinitializers
        (deinit_declaration) @deinit @deinit_def
        
        ; Properties
        (property_declaration name: (pattern (simple_identifier) @property)) @property_def
        
        ; Computed properties
        (computed_property name: (simple_identifier) @computed_property) @computed_property_def
        
        ; Subscripts
        (subscript_declaration) @subscript @subscript_def
        
        ; Operators
        (operator_declaration operator: (custom_operator) @operator) @operator_def
        
        ; Precedence groups
        (precedence_group_declaration name: (simple_identifier) @precedence_group) @precedence_group_def
        
        ; Associated types
        (associated_type_declaration name: (type_identifier) @associated_type) @associated_type_def
        
        ; Type aliases
        (typealias_declaration name: (type_identifier) @typealias) @typealias_def
        
        ; Imports
        (import_declaration (identifier) @import) @import_def
        
        ; Property wrappers
        (attribute_list (attribute name: (user_type (type_identifier) @property_wrapper))) @property_wrapper_def
        
        ; Result builders
        (attribute_list (attribute name: (user_type (type_identifier) @result_builder))) @result_builder_def
        
        ; Protocol conformance
        (type_inheritance_clause (inheritance_constraint type: (type_identifier) @protocol_conformance))
        
        ; Generic constraints
        (generic_where_clause (conformance_constraint type: (type_identifier) @generic_constraint))
        
        ; Method calls
        (call_expression function: (navigation_expression target: (_) property: (navigation_suffix (simple_identifier) @method_call)))
        
        ; Property access
        (navigation_expression target: (_) property: (navigation_suffix (simple_identifier) @property_access))
        
        ; Type references
        (user_type (type_identifier) @type_reference)
        
        ; Variable declarations
        (property_declaration name: (pattern (simple_identifier) @variable)) @variable_def
        
        ; Parameter declarations
        (parameter name: (simple_identifier) @parameter) @parameter_def
        
        ; Closures
        (lambda_literal) @closure @closure_def
        
        ; Guard statements
        (guard_statement) @guard @guard_def
        
        ; Throw statements
        (throw_statement) @throw @throw_def
        
        ; Try expressions
        (try_expression) @try @try_def
        
        ; Async/await
        (await_expression) @await @await_def
        
        ; Actor declarations
        (actor_declaration name: (type_identifier) @actor) @actor_def
    """,
}


class SwiftImportResolver(IImportResolver):
    """Swift-specific import resolver."""

    def __init__(self, project_root: Path):
        self.project_root = project_root
        self.import_graph: Dict[str, Set[str]] = {}
        self.module_cache: Dict[str, Path] = {}

    def resolve_import(self, import_info: ImportInfo, current_file: Path) -> Optional[Path]:
        """Resolve Swift import to file path."""
        module_path = import_info.module_path

        # Check cache first
        if module_path in self.module_cache:
            return self.module_cache[module_path]

        # System frameworks (UIKit, Foundation, etc.)
        if self._is_system_framework(module_path):
            return None  # External dependency

        # Local module resolution
        resolved_path = self._resolve_local_module(module_path, current_file)
        if resolved_path:
            self.module_cache[module_path] = resolved_path

        return resolved_path

    def get_import_graph(self) -> Dict[str, Set[str]]:
        """Get the complete import dependency graph."""
        return self.import_graph.copy()

    def find_circular_dependencies(self) -> List[List[str]]:
        """Find circular dependencies in imports."""
        cycles = []
        visited = set()
        rec_stack = set()

        def dfs(node: str, path: List[str]) -> bool:
            if node in rec_stack:
                # Found cycle
                cycle_start = path.index(node)
                cycles.append(path[cycle_start:] + [node])
                return True

            if node in visited:
                return False

            visited.add(node)
            rec_stack.add(node)
            path.append(node)

            for neighbor in self.import_graph.get(node, set()):
                if dfs(neighbor, path):
                    return True

            rec_stack.remove(node)
            path.pop()
            return False

        for node in self.import_graph:
            if node not in visited:
                dfs(node, [])

        return cycles

    def _is_system_framework(self, module_name: str) -> bool:
        """Check if module is a system framework."""
        system_frameworks = {
            "Foundation",
            "UIKit",
            "SwiftUI",
            "Combine",
            "CoreData",
            "CoreGraphics",
            "QuartzCore",
            "AVFoundation",
            "WebKit",
            "MapKit",
            "CoreLocation",
            "UserNotifications",
            "CloudKit",
        }
        return module_name in system_frameworks

    def _resolve_local_module(self, module_name: str, current_file: Path) -> Optional[Path]:
        """Resolve local module to file path."""
        # Look for Swift files with matching name
        search_dirs = [
            current_file.parent,  # Same directory
            self.project_root,  # Project root
            self.project_root / "Sources",  # SPM Sources directory
        ]

        for search_dir in search_dirs:
            if search_dir.exists():
                # Direct file match
                swift_file = search_dir / f"{module_name}.swift"
                if swift_file.exists():
                    return swift_file

                # Directory with same name
                module_dir = search_dir / module_name
                if module_dir.exists() and module_dir.is_dir():
                    # Look for main file
                    main_file = module_dir / f"{module_name}.swift"
                    if main_file.exists():
                        return main_file

                    # Look for any Swift file in the directory
                    swift_files = list(module_dir.glob("*.swift"))
                    if swift_files:
                        return swift_files[0]

        return None


class SwiftTypeAnalyzer(ITypeAnalyzer):
    """Swift-specific type analyzer."""

    def __init__(self):
        self.type_cache: Dict[str, TypeInfo] = {}
        self.protocol_conformances: Dict[str, Set[str]] = {}
        self.generic_constraints: Dict[str, Dict[str, str]] = {}

    def get_type_info(self, symbol: str, file_path: str) -> Optional[TypeInfo]:
        """Get type information for Swift symbol."""
        cache_key = f"{file_path}::{symbol}"

        if cache_key in self.type_cache:
            return self.type_cache[cache_key]

        # Analyze type from source
        type_info = self._analyze_type(symbol, file_path)
        if type_info:
            self.type_cache[cache_key] = type_info

        return type_info

    def find_implementations(self, protocol_name: str) -> List[Tuple[str, str]]:
        """Find all types that conform to a protocol."""
        implementations = []

        for type_name, protocols in self.protocol_conformances.items():
            if protocol_name in protocols:
                # Extract file path from type name if available
                if "::" in type_name:
                    file_path, actual_type = type_name.split("::", 1)
                    implementations.append((actual_type, file_path))
                else:
                    implementations.append((type_name, ""))

        return implementations

    def resolve_generic_type(self, type_expr: str, context: Dict[str, str]) -> str:
        """Resolve generic type expression."""
        # Handle basic generic substitution
        for generic_param, concrete_type in context.items():
            type_expr = type_expr.replace(f"<{generic_param}>", f"<{concrete_type}>")
            type_expr = type_expr.replace(generic_param, concrete_type)

        return type_expr

    def _analyze_type(self, symbol: str, file_path: str) -> Optional[TypeInfo]:
        """Analyze type information from source code."""
        try:
            content = Path(file_path).read_text()

            # Look for type declaration
            patterns = [
                rf"class\s+{re.escape(symbol)}\s*(<[^>]+>)?\s*:\s*([^{{]+)",
                rf"struct\s+{re.escape(symbol)}\s*(<[^>]+>)?\s*:\s*([^{{]+)",
                rf"enum\s+{re.escape(symbol)}\s*(<[^>]+>)?\s*:\s*([^{{]+)",
                rf"protocol\s+{re.escape(symbol)}\s*(<[^>]+>)?\s*:\s*([^{{]+)",
                rf"actor\s+{re.escape(symbol)}\s*(<[^>]+>)?\s*:\s*([^{{]+)",
            ]

            for pattern in patterns:
                match = re.search(pattern, content, re.MULTILINE)
                if match:
                    generic_params = []
                    if match.group(1):  # Generic parameters
                        generic_str = match.group(1)[1:-1]  # Remove < >
                        generic_params = [p.strip() for p in generic_str.split(",")]

                    super_types = []
                    if match.group(2):  # Inheritance/conformance
                        super_types = [t.strip() for t in match.group(2).split(",")]

                    # Determine if it's a protocol
                    is_interface = "protocol" in pattern

                    return TypeInfo(
                        type_name=symbol,
                        is_generic=bool(generic_params),
                        generic_params=generic_params,
                        is_nullable=False,  # Swift has optionals, not nullables
                        is_interface=is_interface,
                        super_types=super_types,
                    )

        except Exception as e:
            logger.warning(f"Failed to analyze type {symbol} in {file_path}: {e}")

        return None


class SwiftBuildSystem(IBuildSystemIntegration):
    """Swift Package Manager integration."""

    def __init__(self, project_root: Path):
        self.project_root = project_root

    def parse_build_file(self, build_file_path: Path) -> List[BuildDependency]:
        """Parse Package.swift file."""
        dependencies = []

        try:
            content = build_file_path.read_text()

            # Parse Swift Package Manager dependencies
            # Look for .package patterns
            package_patterns = [
                r'\.package\(url:\s*"([^"]+)",\s*from:\s*"([^"]+)"\)',
                r'\.package\(url:\s*"([^"]+)",\s*\.upToNextMajor\(from:\s*"([^"]+)"\)\)',
                r'\.package\(url:\s*"([^"]+)",\s*\.upToNextMinor\(from:\s*"([^"]+)"\)\)',
                r'\.package\(url:\s*"([^"]+)",\s*"([^"]+)"\.\.<"([^"]+)"\)',
            ]

            for pattern in package_patterns:
                matches = re.finditer(pattern, content)
                for match in matches:
                    url = match.group(1)
                    version = match.group(2)

                    # Extract package name from URL
                    name = self._extract_package_name(url)

                    dependencies.append(
                        BuildDependency(
                            name=name, version=version, registry="swift_package_manager"
                        )
                    )

            # Parse target dependencies
            target_deps = self._parse_target_dependencies(content)
            dependencies.extend(target_deps)

        except Exception as e:
            logger.warning(f"Failed to parse Package.swift: {e}")

        return dependencies

    def resolve_external_import(self, import_path: str) -> Optional[str]:
        """Resolve external package import."""
        # This would typically involve checking the package cache
        # For now, return None for external packages
        return None

    def get_project_structure(self) -> Dict[str, Any]:
        """Get Swift project structure."""
        structure = {
            "type": "swift_package",
            "sources": [],
            "tests": [],
            "resources": [],
            "targets": [],
        }

        # Standard SPM structure
        sources_dir = self.project_root / "Sources"
        tests_dir = self.project_root / "Tests"

        if sources_dir.exists():
            structure["sources"] = [str(f) for f in sources_dir.rglob("*.swift")]

        if tests_dir.exists():
            structure["tests"] = [str(f) for f in tests_dir.rglob("*.swift")]

        # Parse Package.swift for targets
        package_file = self.project_root / "Package.swift"
        if package_file.exists():
            try:
                content = package_file.read_text()
                targets = self._parse_targets(content)
                structure["targets"] = targets
            except Exception as e:
                logger.warning(f"Failed to parse targets: {e}")

        return structure

    def _extract_package_name(self, url: str) -> str:
        """Extract package name from Git URL."""
        # Remove .git suffix and extract last component
        name = url.split("/")[-1]
        if name.endswith(".git"):
            name = name[:-4]
        return name

    def _parse_target_dependencies(self, content: str) -> List[BuildDependency]:
        """Parse target dependencies from Package.swift."""
        dependencies = []

        # Look for .target dependencies
        target_pattern = r"\.target\([^)]*dependencies:\s*\[([^\]]+)\]"
        matches = re.finditer(target_pattern, content, re.DOTALL)

        for match in matches:
            deps_str = match.group(1)
            # Parse individual dependencies
            dep_pattern = r'"([^"]+)"'
            dep_matches = re.finditer(dep_pattern, deps_str)

            for dep_match in dep_matches:
                dep_name = dep_match.group(1)
                dependencies.append(
                    BuildDependency(name=dep_name, version="latest", registry="local_target")
                )

        return dependencies

    def _parse_targets(self, content: str) -> List[Dict[str, Any]]:
        """Parse target definitions from Package.swift."""
        targets = []

        # Simple regex-based parsing (could be improved with proper AST parsing)
        target_pattern = r'\.target\(\s*name:\s*"([^"]+)"[^)]*\)'
        matches = re.finditer(target_pattern, content)

        for match in matches:
            target_name = match.group(1)
            targets.append({"name": target_name, "type": "library"})  # Default assumption

        return targets


class SwiftCrossFileAnalyzer(ICrossFileAnalyzer):
    """Swift-specific cross-file analysis."""

    def __init__(self, project_root: Path):
        self.project_root = project_root
        self.file_cache: Dict[str, str] = {}

    def find_all_references(self, symbol: str, definition_file: str) -> List[CrossFileReference]:
        """Find all references to a symbol across Swift files."""
        references = []

        # Search all Swift files in the project
        for swift_file in self.project_root.rglob("*.swift"):
            if swift_file == Path(definition_file):
                continue  # Skip definition file

            try:
                content = self._get_file_content(str(swift_file))
                refs = self._find_symbol_references(symbol, content, str(swift_file))
                references.extend(refs)
            except Exception as e:
                logger.warning(f"Failed to analyze {swift_file}: {e}")

        return references

    def get_call_graph(self, function_name: str) -> Dict[str, Set[str]]:
        """Get call graph for a Swift function."""
        call_graph = {}

        # This would require more sophisticated analysis
        # For now, return empty graph
        return call_graph

    def analyze_impact(self, file_path: str) -> Dict[str, List[str]]:
        """Analyze impact of changes to a Swift file."""
        impact = {
            "direct_dependencies": [],
            "indirect_dependencies": [],
            "test_files": [],
        }

        # Find files that import this file
        file_name = Path(file_path).stem

        for swift_file in self.project_root.rglob("*.swift"):
            if str(swift_file) == file_path:
                continue

            try:
                content = self._get_file_content(str(swift_file))
                if f"import {file_name}" in content:
                    impact["direct_dependencies"].append(str(swift_file))
                elif file_name in content:
                    impact["indirect_dependencies"].append(str(swift_file))
            except Exception as e:
                logger.warning(f"Failed to analyze impact for {swift_file}: {e}")

        return impact

    def _get_file_content(self, file_path: str) -> str:
        """Get file content with caching."""
        if file_path not in self.file_cache:
            self.file_cache[file_path] = Path(file_path).read_text()
        return self.file_cache[file_path]

    def _find_symbol_references(
        self, symbol: str, content: str, file_path: str
    ) -> List[CrossFileReference]:
        """Find references to a symbol in file content."""
        references = []
        lines = content.split("\n")

        for line_num, line in enumerate(lines, 1):
            # Simple pattern matching (could be improved)
            if symbol in line and not line.strip().startswith("//"):
                # Determine reference type
                ref_type = self._determine_reference_type(line, symbol)

                references.append(
                    CrossFileReference(
                        symbol=symbol,
                        source_file=file_path,
                        target_file="",  # Would need definition lookup
                        line_number=line_num,
                        reference_type=ref_type,
                    )
                )

        return references

    def _determine_reference_type(self, line: str, symbol: str) -> str:
        """Determine the type of reference in a line."""
        _ = line.strip()

        if f"{symbol}(" in line:
            return "call"
        elif f"import {symbol}" in line:
            return "import"
        elif f": {symbol}" in line or f"<{symbol}>" in line:
            return "type_usage"
        elif "class " in line and f": {symbol}" in line:
            return "inherit"
        elif "extension " in line and f": {symbol}" in line:
            return "conform"
        else:
            return "reference"


class Plugin(SpecializedPluginBase):
    """Swift language plugin with comprehensive features."""

    lang = "swift"

    def __init__(self, sqlite_store: Optional[SQLiteStore] = None, enable_semantic: bool = True):
        """Initialize Swift plugin."""
        super().__init__(SWIFT_CONFIG, sqlite_store, enable_semantic)

        # Swift-specific components
        self.module_analyzer = SwiftModuleAnalyzer()
        self.protocol_checker = SwiftProtocolChecker()
        self.objc_bridge = ObjectiveCBridge()

        # Find project root
        self._project_root = self._find_project_root()

        # Cache for analyzed files
        self._analyzed_files: Set[str] = set()

    def supports(self, path: str | Path) -> bool:
        """Check if file is supported."""
        path_obj = Path(path)
        return path_obj.suffix.lower() in [".swift"]

    def _create_import_resolver(self) -> IImportResolver:
        """Create Swift import resolver."""
        return SwiftImportResolver(self._project_root or Path.cwd())

    def _create_type_analyzer(self) -> ITypeAnalyzer:
        """Create Swift type analyzer."""
        return SwiftTypeAnalyzer()

    def _create_build_system(self) -> IBuildSystemIntegration:
        """Create Swift build system integration."""
        return SwiftBuildSystem(self._project_root or Path.cwd())

    def _create_cross_file_analyzer(self) -> ICrossFileAnalyzer:
        """Create Swift cross-file analyzer."""
        return SwiftCrossFileAnalyzer(self._project_root or Path.cwd())

    def indexFile(self, path: str | Path, content: str) -> IndexShard:
        """Index Swift file with enhanced analysis."""
        # Get base index
        base_index = super().indexFile(path, content)

        # Enhance with Swift-specific analysis
        file_path = Path(path)

        try:
            # Analyze modules and imports
            imports = self.module_analyzer.analyze_imports(content)

            # Check protocol conformances
            conformances = self.protocol_checker.find_conformances(content)

            # Analyze Objective-C interop
            objc_info = self.objc_bridge.analyze_interop(content)

            # Add Swift-specific symbols to index
            swift_symbols = self._extract_swift_symbols(content, str(file_path))
            base_index["symbols"].extend(swift_symbols)

            # Store additional metadata
            base_index["metadata"] = {
                "imports": [imp.__dict__ for imp in imports],
                "protocol_conformances": conformances,
                "objc_interop": objc_info,
                "has_property_wrappers": "@" in content and "propertyWrapper" in content,
                "has_result_builders": "@" in content and "resultBuilder" in content,
                "has_actors": "actor " in content,
                "has_async_await": "async " in content or "await " in content,
            }

        except Exception as e:
            logger.warning(f"Enhanced Swift analysis failed for {path}: {e}")

        return base_index

    def search(self, query: str, opts: SearchOpts | None = None) -> Iterable[SearchResult]:
        """Enhanced search with Swift-specific features."""
        # Base search
        for result in super().search(query, opts):
            yield result

        # Swift-specific searches
        if opts and opts.get("semantic", False):
            # Protocol conformance search
            if query.startswith("protocol:"):
                protocol_name = query[9:]
                yield from self._search_protocol_conformances(protocol_name)

            # Property wrapper search
            elif query.startswith("@"):
                yield from self._search_property_wrappers(query[1:])

            # Module search
            elif query.startswith("import:"):
                module_name = query[7:]
                yield from self._search_module_usage(module_name)

    def _extract_swift_symbols(self, content: str, file_path: str) -> List[Dict[str, Any]]:
        """Extract Swift-specific symbols."""
        symbols = []

        # Property wrappers
        property_wrappers = re.finditer(r"@(\w+)\s+(?:struct|class)\s+(\w+)", content)
        for match in property_wrappers:
            if match.group(1) in ["propertyWrapper", "resultBuilder"]:
                symbols.append(
                    {
                        "symbol": match.group(2),
                        "kind": match.group(1),
                        "language": "swift",
                        "signature": match.group(0),
                        "doc": None,
                        "defined_in": file_path,
                        "line": content[: match.start()].count("\n") + 1,
                        "span": (match.start(), match.end()),
                    }
                )

        # Actors
        actors = re.finditer(r"actor\s+(\w+)", content)
        for match in actors:
            symbols.append(
                {
                    "symbol": match.group(1),
                    "kind": "actor",
                    "language": "swift",
                    "signature": match.group(0),
                    "doc": None,
                    "defined_in": file_path,
                    "line": content[: match.start()].count("\n") + 1,
                    "span": (match.start(), match.end()),
                }
            )

        return symbols

    def _search_protocol_conformances(self, protocol_name: str) -> Iterable[SearchResult]:
        """Search for protocol conformances."""
        implementations = self.type_analyzer.find_implementations(protocol_name)

        for type_name, file_path in implementations:
            if file_path and Path(file_path).exists():
                try:
                    content = Path(file_path).read_text()
                    lines = content.split("\n")

                    for line_num, line in enumerate(lines, 1):
                        if protocol_name in line and ":" in line:
                            yield SearchResult(
                                file=file_path,
                                start_line=line_num,
                                end_line=line_num,
                                snippet=line.strip(),
                            )
                except Exception as e:
                    logger.warning(f"Failed to search conformances in {file_path}: {e}")

    def _search_property_wrappers(self, wrapper_name: str) -> Iterable[SearchResult]:
        """Search for property wrapper usage."""
        pattern = f"@{wrapper_name}"

        for swift_file in self._project_root.rglob("*.swift"):
            try:
                content = swift_file.read_text()
                lines = content.split("\n")

                for line_num, line in enumerate(lines, 1):
                    if pattern in line:
                        yield SearchResult(
                            file=str(swift_file),
                            start_line=line_num,
                            end_line=line_num,
                            snippet=line.strip(),
                        )
            except Exception as e:
                logger.warning(f"Failed to search property wrappers in {swift_file}: {e}")

    def _search_module_usage(self, module_name: str) -> Iterable[SearchResult]:
        """Search for module import and usage."""
        pattern = f"import {module_name}"

        for swift_file in self._project_root.rglob("*.swift"):
            try:
                content = swift_file.read_text()
                lines = content.split("\n")

                for line_num, line in enumerate(lines, 1):
                    if pattern in line:
                        yield SearchResult(
                            file=str(swift_file),
                            start_line=line_num,
                            end_line=line_num,
                            snippet=line.strip(),
                        )
            except Exception as e:
                logger.warning(f"Failed to search module usage in {swift_file}: {e}")

    def _find_project_root(self) -> Optional[Path]:
        """Find Swift project root by looking for Package.swift."""
        current = Path.cwd()

        while current != current.parent:
            if (current / "Package.swift").exists():
                return current
            if (current / ".git").exists():
                return current
            current = current.parent

        return Path.cwd()

    def _discover_build_files(self):
        """Discover Swift build files."""
        if self._project_root:
            package_swift = self._project_root / "Package.swift"
            if package_swift.exists():
                self._build_files = [package_swift]

            # Also look for Xcode project files
            _ = list(self._project_root.glob("*.xcodeproj"))
            _ = list(self._project_root.glob("*.xcworkspace"))

            # Note: We don't parse Xcode files yet, but we could extend this

    def analyze_imports(self, file_path: Path) -> List[ImportInfo]:
        """Analyze imports in a Swift file."""
        try:
            content = file_path.read_text()
            return self.module_analyzer.analyze_imports(content)
        except Exception as e:
            logger.warning(f"Failed to analyze imports in {file_path}: {e}")
            return []

    def get_protocol_conformances(self, file_path: str) -> Dict[str, List[str]]:
        """Get protocol conformances for types in a file."""
        try:
            content = Path(file_path).read_text()
            return self.protocol_checker.find_conformances(content)
        except Exception as e:
            logger.warning(f"Failed to analyze protocol conformances in {file_path}: {e}")
            return {}

    def get_objc_bridging_info(self, file_path: str) -> Dict[str, Any]:
        """Get Objective-C bridging information."""
        try:
            content = Path(file_path).read_text()
            return self.objc_bridge.analyze_interop(content)
        except Exception as e:
            logger.warning(f"Failed to analyze Objective-C interop in {file_path}: {e}")
            return {}
