from typing import Protocol, List, Tuple, Dict, Any, Optional
from arc_memory.schema.models import Node, Edge

class IngestorPlugin(Protocol):
    def get_name(self) -> str:
        """Return a unique name for this plugin."""
        ...
    
    def get_node_types(self) -> List[str]:
        """Return a list of node types this plugin can create."""
        ...
    
    def get_edge_types(self) -> List[str]:
        """Return a list of edge types this plugin can create."""
        ...
    
    def ingest(self, last_processed: Optional[Dict[str, Any]] = None) -> Tuple[List[Node], List[Edge], Dict[str, Any]]:
        """
        Ingest data from the source and return nodes, edges, and metadata.
        
        Args:
            last_processed: Optional dictionary containing metadata from the previous run,
                            used for incremental ingestion.
        
        Returns:
            A tuple containing:
            - List[Node]: List of nodes created from the data source
            - List[Edge]: List of edges created from the data source
            - Dict[str, Any]: Metadata about the ingestion process, used for incremental builds
        """
        ...

class IngestorRegistry:
    def __init__(self):
        """Initialize an empty registry."""
        self.ingestors: Dict[str, IngestorPlugin] = {}
    
    def register(self, ingestor: IngestorPlugin) -> None:
        """Register a plugin with the registry."""
        self.ingestors[ingestor.get_name()] = ingestor
    
    def get(self, name: str) -> Optional[IngestorPlugin]:
        """Get a plugin by name."""
        return self.ingestors.get(name)
    
    def list_plugins(self) -> List[str]:
        """List all registered plugins."""
        return list(self.ingestors.keys())
    
    def get_all(self) -> List[IngestorPlugin]:
        """Get all registered plugins."""
        return list(self.ingestors.values())

import pkg_resources
import logging
from typing import Type

logger = logging.getLogger(__name__)

def discover_plugins() -> IngestorRegistry:
    """Discover and register all available plugins."""
    registry = IngestorRegistry()
    
    # Register built-in plugins
    from arc_memory.ingest.git import GitIngestor
    from arc_memory.ingest.github import GitHubIngestor
    from arc_memory.ingest.adr import ADRIngestor
    
    registry.register(GitIngestor())
    registry.register(GitHubIngestor())
    registry.register(ADRIngestor())
    
    # Discover and register third-party plugins
    for entry_point in pkg_resources.iter_entry_points('arc_memory.plugins'):
        try:
            plugin_class: Type[IngestorPlugin] = entry_point.load()
            registry.register(plugin_class())
            logger.info(f"Loaded plugin: {entry_point.name}")
        except Exception as e:
            logger.warning(f"Failed to load plugin {entry_point.name}: {e}")
    
    return registry

def build_graph(
    repo_path: Path,
    output_path: Path,
    incremental: bool = False,
    plugins: Optional[List[str]] = None
) -> None:
    """Build the knowledge graph using available plugins."""
    # Discover plugins
    registry = discover_plugins()
    
    # Filter plugins if specified
    active_plugins = registry.get_all()
    if plugins:
        active_plugins = [p for p in active_plugins if p.get_name() in plugins]
    
    # Load existing manifest for incremental builds
    manifest = None
    if incremental:
        manifest = load_build_manifest()
    
    # Initialize lists for all nodes and edges
    all_nodes = []
    all_edges = []
    
    # Process each plugin
    for plugin in active_plugins:
        plugin_name = plugin.get_name()
        logger.info(f"Processing plugin: {plugin_name}")
        
        # Get last processed data for this plugin
        last_processed = None
        if manifest and incremental:
            last_processed = manifest.last_processed.get(plugin_name, {})
        
        # Run the plugin
        nodes, edges, metadata = plugin.ingest(last_processed)
        
        # Add results to the combined lists
        all_nodes.extend(nodes)
        all_edges.extend(edges)
        
        # Update manifest
        if manifest:
            manifest.last_processed[plugin_name] = metadata
    
    # Write to database
    # ... (existing database write code)
    
    # Update and save manifest
    # ... (existing manifest update code)

class BaseIngestor(ABC):
    @abstractmethod
    def get_name(self) -> str: ...
    
    @abstractmethod
    def ingest(self, last_processed: Optional[Dict] = None) -> Tuple[List[Node], List[Edge], Dict]: ...

def register_plugin(name: str):
    def decorator(func):
        PLUGINS[name] = func
        return func
    return decorator

@register_plugin("github")
def ingest_github(last_processed=None):
    # Implementation
    return nodes, edges, metadata

# ~/.arc/plugins.yaml
plugins:
  - name: github
    enabled: true
    module: arc_memory.ingest.github
    class: GitHubIngestor