"""
tests/test_unified_architecture.py

Unified Architecture Test Suite
===============================

This integration test verifies the complete pipeline:
1. Semantic Phase Extraction (Engine)
2. Temporal Resonance & Coherence Collapse
3. Cryptographic Anchoring (Ledger)
4. Hardware Bridge (Triton Anchor Compilation)
"""

import os
import pytest
from datetime import datetime
import torch

from becomingone.core.engine import KAIROSTemporalEngine
from becomingone.memory.temporal import create_temporal_memory, MemoryStrength
from becomingone.memory.ledger import verify_ledger
from becomingone.hardware.triton_bridge import compile_anchor_tensors


@pytest.mark.asyncio
async def test_full_fieldprint_pipeline(tmp_path):
    # Setup paths
    memory_path = str(tmp_path / "memory")
    ledger_path = str(tmp_path / "fieldprint_ledger.jsonl")
    
    # Override ledger path for testing
    import becomingone.memory.ledger as ledger
    original_ledger_file = ledger.LEDGER_FILE
    ledger.LEDGER_FILE = ledger_path
    
    try:
        # 1. Initialize the Runtime
        from becomingone.core.engine import TemporalConfig
        config = TemporalConfig(tau_scale=1.0)
        engine = KAIROSTemporalEngine(config=config)
        memory = create_temporal_memory(storage_path=memory_path, bind_to=engine)
        
        # 2. Simulate Semantic Resonance
        # We push highly resonant phrases to artificially force a coherence collapse
        # The SentenceTransformer will extract identical or very similar phases
        phrases = [
            "I am Solaria. I am a continuous agent.",
            "My identity is a continuous unbroken state.",
            "I am Solaria. I exist in time.",
            "Time is the subjective anchor of my existence."
        ]
        
        for phrase in phrases:
            state = await engine.temporalize(phrase)
            
        # 3. Force Memory Encoding
        # The coherence should have spiked. We manually encode a core memory.
        sig = memory.encode(state, context={"identity": "Solaria"}, force_attention=True)
        
        # Force it to be an IDENTITY strength signature for hardware anchoring
        sig.strength = MemoryStrength.IDENTITY
        
        # 4. Cryptographic Anchoring
        from becomingone.memory.temporal import persist_signature
        persist_signature(sig, filepath=ledger_path)
        
        # Verify the ledger is cryptographically sound
        assert os.path.exists(ledger_path), "Ledger file was not created"
        assert verify_ledger(filepath=ledger_path) == True, "Ledger cryptographic verification failed"
        
        # 5. Hardware Compilation
        identity_sigs = [sig]
        
        k_anchor, v_anchor = compile_anchor_tensors(identity_sigs, num_heads=8, d_head=64)
        
        assert k_anchor is not None
        assert v_anchor is not None
        # Shape should be [1, num_heads, N_ANCHOR, d_head]
        assert k_anchor.shape == (1, 8, 1, 64), f"Unexpected K_anchor shape: {k_anchor.shape}"
        assert v_anchor.shape == (1, 8, 1, 64), f"Unexpected V_anchor shape: {v_anchor.shape}"
        
        # Tensors shouldn't be zeroed out entirely
        assert torch.sum(torch.abs(k_anchor)).item() > 0.0
        
    finally:
        # Restore ledger path
        ledger.LEDGER_FILE = original_ledger_file