"""
scripts/knowledge/auto_update.py — Auto-update orchestrator.

Runs the full KG → Obsidian conversion + Mermaid diagram generation
pipeline in a single call.  Designed to be invoked from cron, epoch
pipeline, or manually.

Usage:
    from scripts.knowledge.auto_update import AutoKGUpdate
    updater = AutoKGUpdate()
    stats = updater.run()
    print(updater.get_stats())

CLI:
    python3 scripts/knowledge/auto_update.py

# VERIFICATION_STAMP
# Story: 12.04 — AutoKGUpdate
# Verified By: parallel-builder
# Verified At: 2026-02-25
# Tests: 9/9
# Coverage: 100%
"""

import json
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, Optional

from scripts.knowledge.kg_to_obsidian import KGToObsidian
from scripts.knowledge.mermaid_generator import MermaidGenerator


class AutoKGUpdate:
    """
    Orchestrates the complete KG → Obsidian vault + Mermaid diagrams pipeline.

    Attributes:
        kg_path:            Path to KNOWLEDGE_GRAPH directory.
        vault_path:         Path where Obsidian vault will be written.
        diagram_output_path: Path where Mermaid diagram .md files will be written.
    """

    def __init__(
        self,
        kg_path: str = "/mnt/e/genesis-system/KNOWLEDGE_GRAPH",
        vault_path: str = "/mnt/e/genesis-system/obsidian-vault",
        diagram_output_path: str = "/mnt/e/genesis-system/obsidian-vault/diagrams",
    ) -> None:
        self.kg_path = kg_path
        self.vault_path = vault_path
        self.diagram_output_path = diagram_output_path
        self._last_stats: Dict[str, Any] = {}

    # ------------------------------------------------------------------
    # Public API
    # ------------------------------------------------------------------

    def run(self) -> Dict[str, Any]:
        """
        Execute the full pipeline:
          1. Convert KG JSONL files → Obsidian markdown vault
          2. Generate Mermaid architecture diagrams
          3. Write timestamp file to vault

        Returns:
            Stats dict with counts and timing.
        """
        started_at = datetime.now(tz=timezone.utc)

        # Step 1: KG → Obsidian
        converter = KGToObsidian(
            kg_path=self.kg_path,
            vault_path=self.vault_path,
        )
        kg_stats = converter.convert_all()

        # Step 2: Mermaid diagrams
        # Derive repo path (two levels up from KG path)
        repo_path = str(Path(self.kg_path).parent)
        generator = MermaidGenerator(repo_path=repo_path)
        diagrams = generator.generate_all(output_dir=self.diagram_output_path)
        diagram_count = len(diagrams)

        # Step 3: Write timestamp
        finished_at = datetime.now(tz=timezone.utc)
        elapsed_s = (finished_at - started_at).total_seconds()
        self._write_timestamp(started_at, finished_at, kg_stats, diagram_count)

        self._last_stats = {
            "started_at": started_at.isoformat(),
            "finished_at": finished_at.isoformat(),
            "elapsed_seconds": round(elapsed_s, 2),
            "entities_converted": kg_stats.get("entities", 0),
            "axioms_converted": kg_stats.get("axioms", 0),
            "conversion_errors": kg_stats.get("errors", 0),
            "diagrams_generated": diagram_count,
            "vault_path": self.vault_path,
            "diagram_path": self.diagram_output_path,
        }
        return self._last_stats

    def get_stats(self) -> Dict[str, Any]:
        """
        Return stats from the last run() call.
        Returns an empty dict if run() has not been called yet.
        """
        return dict(self._last_stats)

    # ------------------------------------------------------------------
    # Internal helpers
    # ------------------------------------------------------------------

    def _write_timestamp(
        self,
        started_at: datetime,
        finished_at: datetime,
        kg_stats: Dict[str, int],
        diagram_count: int,
    ) -> None:
        """Write a LAST_RUN.json file to the vault root."""
        vault = Path(self.vault_path)
        vault.mkdir(parents=True, exist_ok=True)
        ts_path = vault / "LAST_RUN.json"
        payload = {
            "started_at": started_at.isoformat(),
            "finished_at": finished_at.isoformat(),
            "entities_converted": kg_stats.get("entities", 0),
            "axioms_converted": kg_stats.get("axioms", 0),
            "conversion_errors": kg_stats.get("errors", 0),
            "diagrams_generated": diagram_count,
        }
        ts_path.write_text(
            json.dumps(payload, indent=2, ensure_ascii=False),
            encoding="utf-8",
        )


# ------------------------------------------------------------------
# CLI entry-point
# ------------------------------------------------------------------

if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Genesis KG → Obsidian auto-update")
    parser.add_argument(
        "--kg-path",
        default="/mnt/e/genesis-system/KNOWLEDGE_GRAPH",
        help="Path to KNOWLEDGE_GRAPH directory",
    )
    parser.add_argument(
        "--vault-path",
        default="/mnt/e/genesis-system/obsidian-vault",
        help="Output Obsidian vault path",
    )
    parser.add_argument(
        "--diagrams-path",
        default="/mnt/e/genesis-system/obsidian-vault/diagrams",
        help="Output directory for Mermaid diagram files",
    )
    args = parser.parse_args()

    updater = AutoKGUpdate(
        kg_path=args.kg_path,
        vault_path=args.vault_path,
        diagram_output_path=args.diagrams_path,
    )
    stats = updater.run()
    print(json.dumps(stats, indent=2))