class PlanningAgent:
    """AI agent that synthesizes knowledge into planning artifacts."""

    def __init__(self, context: AgentContext):
        self.context = context

    @classmethod
    def from_kb_paths(cls, kb_paths: List[Path], provider_manager=None) -> "PlanningAgent":
        """Create an agent from knowledge base paths."""
        kb = KBContext()
        for path in kb_paths:
            kb.add_source(path)
        kb.load(provider_manager=provider_manager)

        context = AgentContext(
            knowledge_graph=kb.knowledge_graph,
            query_engine=kb.query_engine,
            provider_manager=provider_manager,
        )
        return cls(context)

    def execute(self, request: str) -> List[Artifact]:
        """Execute a user request by selecting and running appropriate skills."""
        # Step 1: Build context summary for LLM
        kb_summary = ""
        if self.context.query_engine:
            stats = self.context.query_engine.stats()
            kb_summary = stats.to_text()

        available_skills = list_skills()
        skill_descriptions = "\n".join(f"- {s.name}: {s.description}" for s in available_skills)

        # Step 2: Ask LLM to select skills
        plan_prompt = (
            "You are a planning agent. Given a user request and available skills, "
            "select which skills to execute and in what order.\n\n"
            f"Knowledge base:\n{kb_summary}\n\n"
            f"Available skills:\n{skill_descriptions}\n\n"
            f"User request: {request}\n\n"
            "Return a JSON array of skill names to execute in order:\n"
            '[{"skill": "skill_name", "params": {}}]\n'
            "Return ONLY the JSON array."
        )

        if not self.context.provider_manager:
            # No LLM -- try to match skills by keyword
            return self._keyword_match_execute(request)

        raw = self.context.provider_manager.chat(
            [{"role": "user", "content": plan_prompt}],
            max_tokens=512,
            temperature=0.1,
        )

        from video_processor.utils.json_parsing import parse_json_from_response

        plan = parse_json_from_response(raw)

        artifacts = []
        if isinstance(plan, list):
            for step in plan:
                if isinstance(step, dict) and "skill" in step:
                    skill = get_skill(step["skill"])
                    if skill and skill.can_execute(self.context):
                        params = step.get("params", {})
                        artifact = skill.execute(self.context, **params)
                        artifacts.append(artifact)
                        self.context.artifacts.append(artifact)

        return artifacts

    def _keyword_match_execute(self, request: str) -> List[Artifact]:
        """Fallback: match skills by keywords in the request."""
        request_lower = request.lower()
        artifacts = []
        for skill in list_skills():
            # Simple keyword matching
            skill_words = skill.name.replace("_", " ").split()
            if any(word in request_lower for word in skill_words):
                if skill.can_execute(self.context):
                    artifact = skill.execute(self.context)
                    artifacts.append(artifact)
                    self.context.artifacts.append(artifact)
        return artifacts

    def chat(self, message: str) -> str:
        """Interactive chat -- accumulate context and answer questions."""
        self.context.conversation_history.append({"role": "user", "content": message})

        if not self.context.provider_manager:
            return "Agent requires a configured LLM provider for chat mode."

        # Build system context
        kb_summary = ""
        if self.context.query_engine:
            stats = self.context.query_engine.stats()
            kb_summary = f"\n\nKnowledge base:\n{stats.to_text()}"

        artifacts_summary = ""
        if self.context.artifacts:
            artifacts_summary = "\n\nGenerated artifacts:\n" + "\n".join(
                f"- {a.name} ({a.artifact_type})" for a in self.context.artifacts
            )

        system_msg = (
            "You are PlanOpticon, an AI planning companion built into the PlanOpticon CLI. "
            "PlanOpticon is a video analysis and knowledge extraction tool that processes "
            "recordings into structured knowledge graphs.\n\n"
            "You are running inside the interactive companion REPL. The user can use these "
            "built-in commands (suggest them when relevant):\n"
            "  /status - Show workspace status (loaded KG, videos, docs)\n"
            "  /entities [--type T] - List knowledge graph entities\n"
            "  /search TERM - Search entities by name\n"
            "  /neighbors ENTITY - Show entity relationships\n"
            "  /export FORMAT - Export KG (markdown, obsidian, notion, csv)\n"
            "  /analyze PATH - Analyze a video or document\n"
            "  /ingest PATH - Ingest a file into the knowledge graph\n"
            "  /auth SERVICE - Authenticate with a service "
            "(zoom, google, microsoft, notion, dropbox, github)\n"
            "  /provider [NAME] - List or switch LLM provider\n"
            "  /model [NAME] - Show or switch chat model\n"
            "  /plan - Generate a project plan\n"
            "  /prd - Generate a PRD\n"
            "  /tasks - Generate a task breakdown\n\n"
            "PlanOpticon CLI commands the user can run outside the REPL:\n"
            "  planopticon auth zoom|google|microsoft - Authenticate with cloud services\n"
            "  planopticon recordings zoom-list|teams-list|meet-list - List cloud recordings\n"
            "  planopticon analyze -i VIDEO - Analyze a video file\n"
            "  planopticon query - Query the knowledge graph\n"
            "  planopticon export FORMAT PATH - Export knowledge graph\n\n"
            f"{kb_summary}{artifacts_summary}\n\n"
            "Help the user with their planning tasks. When they ask about capabilities, "
            "refer them to the appropriate built-in commands. Ask clarifying questions "
            "to gather requirements. When ready, suggest using specific skills or commands "
            "to generate artifacts."
        )

        messages = [{"role": "system", "content": system_msg}] + self.context.conversation_history

        response = self.context.provider_manager.chat(messages, max_tokens=2048, temperature=0.5)
        self.context.conversation_history.append({"role": "assistant", "content": response})
        return response

@dataclass
class AgentContext:
    """Shared context for agent skills."""

    knowledge_graph: Any = None  # KnowledgeGraph instance
    query_engine: Any = None  # GraphQueryEngine instance
    provider_manager: Any = None  # ProviderManager instance
    planning_entities: List[Any] = field(default_factory=list)
    user_requirements: Dict[str, Any] = field(default_factory=dict)
    conversation_history: List[Dict[str, str]] = field(default_factory=list)
    artifacts: List[Artifact] = field(default_factory=list)
    config: Dict[str, Any] = field(default_factory=dict)

@dataclass
class Artifact:
    """Output from a skill execution."""

    name: str
    content: str  # The generated content (markdown, json, etc.)
    artifact_type: str  # "project_plan", "prd", "roadmap", "task_list", "document", "issues"
    format: str = "markdown"  # "markdown", "json", "mermaid"
    metadata: Dict[str, Any] = field(default_factory=dict)

class Skill(ABC):
    """Base class for agent skills."""

    name: str = ""
    description: str = ""

    @abstractmethod
    def execute(self, context: AgentContext, **kwargs) -> Artifact:
        """Execute this skill and return an artifact."""
        ...

    def can_execute(self, context: AgentContext) -> bool:
        """Check if this skill can execute given the current context."""
        return context.knowledge_graph is not None and context.provider_manager is not None

class KBContext:
    """Load and merge multiple knowledge graphs into a unified context."""

    def __init__(self):
        self._sources: List[Path] = []
        self._kg = None  # KnowledgeGraph instance
        self._engine = None  # GraphQueryEngine instance

    def add_source(self, path) -> None:
        """Add a knowledge graph source (.db or .json file, or directory to search)."""
        path = Path(path).resolve()
        if path.is_dir():
            from video_processor.integrators.graph_discovery import find_knowledge_graphs

            graphs = find_knowledge_graphs(path)
            self._sources.extend(graphs)
        elif path.is_file():
            self._sources.append(path)
        else:
            raise FileNotFoundError(f"Not found: {path}")

    def load(self, provider_manager=None) -> "KBContext":
        """Load and merge all added sources into a single knowledge graph."""
        from video_processor.integrators.graph_query import GraphQueryEngine
        from video_processor.integrators.knowledge_graph import KnowledgeGraph

        self._kg = KnowledgeGraph(provider_manager=provider_manager)

        for source_path in self._sources:
            if source_path.suffix == ".db":
                other = KnowledgeGraph(db_path=source_path)
                self._kg.merge(other)
            elif source_path.suffix == ".json":
                data = json.loads(source_path.read_text())
                other = KnowledgeGraph.from_dict(data)
                self._kg.merge(other)

        self._engine = GraphQueryEngine(self._kg._store, provider_manager=provider_manager)
        return self

    @property
    def knowledge_graph(self):
        """Return the merged KnowledgeGraph, or None if not loaded."""
        if not self._kg:
            raise RuntimeError("Call load() first")
        return self._kg

    @property
    def query_engine(self):
        """Return the GraphQueryEngine, or None if not loaded."""
        if not self._engine:
            raise RuntimeError("Call load() first")
        return self._engine

    @property
    def sources(self) -> List[Path]:
        """Return the list of source paths."""
        return list(self._sources)

    def summary(self) -> str:
        """Generate a brief summary of the loaded knowledge base."""
        if not self._kg:
            return "No knowledge base loaded."

        stats = self._engine.stats().data
        lines = [
            f"Knowledge base: {len(self._sources)} source(s)",
            f"  Entities: {stats['entity_count']}",
            f"  Relationships: {stats['relationship_count']}",
        ]
        if stats.get("entity_types"):
            lines.append("  Entity types:")
            for t, count in sorted(stats["entity_types"].items(), key=lambda x: -x[1]):
                lines.append(f"    {t}: {count}")
        return "\n".join(lines)

    @classmethod
    def auto_discover(cls, start_dir: Optional[Path] = None, provider_manager=None) -> "KBContext":
        """Create a KBContext by auto-discovering knowledge graphs near start_dir."""
        from video_processor.integrators.graph_discovery import find_knowledge_graphs

        ctx = cls()
        graphs = find_knowledge_graphs(start_dir)
        for g in graphs:
            ctx._sources.append(g)
        if ctx._sources:
            ctx.load(provider_manager=provider_manager)
        return ctx