#!/usr/bin/env python3
"""
Brain Ingestion: Memory_v2 Graph Sync

!!! DEPRECATED — DO NOT RUN !!!
Archived: 2026-05-26
Reason: memory_v2 fully merged into brain unified system (Phase 1-3 complete).
        All 9 entities migrated to brain entities table.
        Directory moved to ~/.hermes/memory_v2_archived/

This script is kept for historical reference only.
"""

# If someone accidentally runs this, fail fast.
import sys
if __name__ == '__main__':
    print("ERROR: This script is DEPRECATED.")
    print("memory_v2 has been fully merged into the brain unified system.")
    print("All entities are now in the brain entities table.")
    print("See: ~/.hermes/brain/UNIFIED_SYSTEM_PLAN.md")
    sys.exit(1)

import json
import sys
from pathlib import Path

# Add brain to path
BRAIN_DIR = Path.home() / '.hermes' / 'brain'
sys.path.insert(0, str(BRAIN_DIR))

from brain import init_brain, log_event, query_events


def purge_existing():
    """Remove previously ingested memory_v2 events."""
    init_brain()
    events = query_events(event_type='knowledge_ingest', tool='memory_v2_sync', limit=10000)
    if not events:
        print("  No existing memory_v2 events to purge")
        return 0

    brain_dir = Path.home() / '.hermes' / 'brain'
    db_path = brain_dir / 'index' / 'events.db'

    event_ids = [e['id'] for e in events]
    try:
        import sqlite3
        db = sqlite3.connect(str(db_path))
        batch_size = 500
        for i in range(0, len(event_ids), batch_size):
            batch = event_ids[i:i+batch_size]
            placeholders = ','.join(['?'] * len(batch))
            db.execute(f"DELETE FROM events WHERE id IN ({placeholders})", batch)
        db.commit()
        db.close()
    except Exception as e:
        print(f"  Warning: purge error: {e}")

    return len(event_ids)


def ingest_memory_v2():
    """Parse and ingest all memory_v2 graph nodes."""
    init_brain()

    # Check archived location first, then legacy location
    graph_path = Path.home() / '.hermes' / 'memory_v2_archived' / 'graph.json'
    if not graph_path.exists():
        graph_path = Path.home() / '.hermes' / 'memory_v2' / 'graph.json'
    if not graph_path.exists():
        print("Error: memory_v2/graph.json not found (archived to memory_v2_archived/)")
        return 0

    with open(graph_path) as f:
        graph = json.load(f)

    nodes = graph.get('nodes', {})
    edges = graph.get('edges', {})

    if not nodes:
        print("  No nodes to ingest")
        return 0

    print(f"Purging existing memory_v2 events...")
    purged = purge_existing()
    if purged:
        print(f"  Purged {purged} events")

    print(f"\nIngesting {len(nodes)} memory_v2 nodes...")
    count = 0

    for node_id, node in nodes.items():
        node_type = node.get('type', 'unknown')
        category = node.get('category', 'uncategorized')
        strength = node.get('strength', 'normal')
        pinned = node.get('pinned', False)
        data = node.get('data', '')
        access_count = node.get('access_count', 0)
        last_accessed = node.get('last_accessed', '')

        tags = [
            'memory_v2',
            node_type,
            category,
            f'strength:{strength}',
        ]
        if pinned:
            tags.append('pinned')

        # Extract sub-category tags from data field
        # Data format: "[tag] [P:LEVEL] actual content"
        if data:
            bracket_tags = []
            temp = data
            while '[' in temp:
                start = temp.index('[')
                end = temp.index(']')
                if end > start:
                    bracket_tags.append(temp[start+1:end].lower())
                    temp = temp[end+1:]
                else:
                    break
            tags.extend(bracket_tags)

        context = {
            'type': 'memory_v2_node',
            'node_id': node_id,
            'node_type': node_type,
            'category': category,
            'strength': strength,
            'pinned': pinned,
            'access_count': access_count,
            'last_accessed': last_accessed,
            'data': data,
        }

        log_event(
            event_type='knowledge_ingest',
            tool='memory_v2_sync',
            args={'node_id': node_id, 'type': node_type, 'category': category},
            context=context,
            tags=tags,
            skip_synapse=True,
        )
        count += 1
        print(f"  [{count}/{len(nodes)}] {node_id} ({node_type}/{category})")

    # Ingest edges as relationships
    if edges:
        print(f"\nIngesting {len(edges)} memory_v2 edges...")
        edge_count = 0
        for edge in edges:
            src = edge.get('from', '')
            tgt = edge.get('to', '')
            weight = edge.get('weight', 1.0)
            edge_type = edge.get('type', 'unknown')

            log_event(
                event_type='knowledge_ingest',
                tool='memory_v2_sync',
                args={'source': src, 'target': tgt, 'weight': weight, 'type': edge_type},
                context={
                    'type': 'memory_v2_edge',
                    'source': src,
                    'target': tgt,
                    'weight': weight,
                    'edge_type': edge_type,
                },
                tags=['memory_v2', 'relationship', src, tgt],
                skip_synapse=True,
            )
            edge_count += 1

        print(f"  Ingested {edge_count} edges")

    return count


def test_queries():
    """Verify ingestion with semantic queries."""
    init_brain()

    queries = [
        ("user preferences", "Should find pinned user prefs"),
        ("Grepples identity", "Should find user identity node"),
        ("worksheet design", "Should find worksheet preferences"),
        ("seedvault project", "Should find project nodes"),
        ("communication rules", "Should find no_assumptions_rule"),
    ]

    print("\n=== TEST QUERIES ===")
    for query, expected in queries:
        results = query_events(
            event_type='knowledge_ingest',
            tool='memory_v2_sync',
            full_text_search=query,
            limit=3,
        )
        status = "✓" if results else "✗"
        print(f"  {status} '{query}' → {len(results)} results ({expected})")
        if results:
            for r in results[:2]:
                ctx = r.get('context', {})
                print(f"      - {ctx.get('node_id', '?')}: {ctx.get('data', '')[:80]}")


if __name__ == '__main__':
    print("=" * 60)
    print("Memory v2 → Brain Sync Pipeline")
    print("=" * 60)

    count = ingest_memory_v2()
    print(f"\nTotal ingested: {count}")

    test_queries()
    print("\nDone.")