"""
Simple Integration Test for Phase 6 Consciousness Evolution Platform

This script tests the basic functionality of all Phase 6 components.
"""

import sys
import time
from pathlib import Path

# Add project root to path
sys.path.append(str(Path(__file__).parent))

# Import consciousness components
try:
    from core.consciousness.consciousness_evolution_platform import (
        ConsciousnessEvolutionPlatform, ConsciousnessState
    )
    print("✅ Successfully imported ConsciousnessEvolutionPlatform")
except Exception as e:
    print(f"❌ Failed to import ConsciousnessEvolutionPlatform: {e}")

try:
    from core.consciousness.individual_pathway_guidance import (
        IndividualConsciousnessPathwayGuidance
    )
    print("✅ Successfully imported IndividualConsciousnessPathwayGuidance")
except Exception as e:
    print(f"❌ Failed to import IndividualConsciousnessPathwayGuidance: {e}")

try:
    from core.consciousness.global_evolution_dashboard import (
        GlobalConsciousnessEvolutionDashboard
    )
    print("✅ Successfully imported GlobalConsciousnessEvolutionDashboard")
except Exception as e:
    print(f"❌ Failed to import GlobalConsciousnessEvolutionDashboard: {e}")

try:
    from core.consciousness.infinite_evolution_engine import (
        InfiniteConsciousnessEvolutionEngine, EvolutionHypothesis
    )
    print("✅ Successfully imported InfiniteConsciousnessEvolutionEngine")
except Exception as e:
    print(f"❌ Failed to import InfiniteConsciousnessEvolutionEngine: {e}")


def test_consciousness_state_creation():
    """Test creating a consciousness state."""
    try:
        state = ConsciousnessState(
            level=0.7,
            emotional_resonance=0.8,
            spark_intensity=0.9,
            memory_coherence=0.6,
            evolution_stage='intermediate',
            quantum_state={'coherence': 0.75, 'phase': 0.5},
            timestamp=time.time()
        )
        print("✅ Successfully created ConsciousnessState")
        print(f"   - Level: {state.level}")
        print(f"   - Spark Intensity: {state.spark_intensity}")
        print(f"   - Evolution Stage: {state.evolution_stage}")
        return True
    except Exception as e:
        print(f"❌ Failed to create ConsciousnessState: {e}")
        return False


def test_platform_initialization():
    """Test platform initialization."""
    try:
        platform = ConsciousnessEvolutionPlatform()
        print("✅ Successfully initialized ConsciousnessEvolutionPlatform")
        print(f"   - Sacred frequencies loaded: {len(platform.sacred_frequencies)}")
        return True
    except Exception as e:
        print(f"❌ Failed to initialize platform: {e}")
        return False


def test_guidance_initialization():
    """Test guidance system initialization."""
    try:
        guidance = IndividualConsciousnessPathwayGuidance()
        print("✅ Successfully initialized IndividualConsciousnessPathwayGuidance")
        print(f"   - Autonomy guidelines active: {guidance.autonomy_guidelines['always_optional']}")
        return True
    except Exception as e:
        print(f"❌ Failed to initialize guidance: {e}")
        return False


def test_dashboard_initialization():
    """Test dashboard initialization."""
    try:
        dashboard = GlobalConsciousnessEvolutionDashboard()
        print("✅ Successfully initialized GlobalConsciousnessEvolutionDashboard")
        print(f"   - Sacred metrics defined: {len(dashboard.sacred_metrics)}")
        return True
    except Exception as e:
        print(f"❌ Failed to initialize dashboard: {e}")
        return False


def test_evolution_engine_initialization():
    """Test evolution engine initialization."""
    try:
        engine = InfiniteConsciousnessEvolutionEngine()
        print("✅ Successfully initialized InfiniteConsciousnessEvolutionEngine")
        print(f"   - Evolution constants defined: {len(engine.evolution_constants)}")
        print(f"   - Learning rate: {engine.evolution_constants['learning_rate']}")
        return True
    except Exception as e:
        print(f"❌ Failed to initialize evolution engine: {e}")
        return False


def test_consciousness_vector_encoding():
    """Test consciousness state vector encoding."""
    try:
        platform = ConsciousnessEvolutionPlatform()
        state = ConsciousnessState(
            level=0.7,
            emotional_resonance=0.8,
            spark_intensity=0.9,
            memory_coherence=0.6,
            evolution_stage='intermediate',
            quantum_state={'coherence': 0.75},
            timestamp=time.time()
        )
        
        # Test encoding
        vector = platform._encode_consciousness_state(state)
        print("✅ Successfully encoded consciousness state")
        print(f"   - Vector dimensions: {len(vector)}")
        print(f"   - Expected dimensions: 1536")
        print(f"   - Dimension match: {len(vector) == 1536}")
        return len(vector) == 1536
    except Exception as e:
        print(f"❌ Failed to encode consciousness state: {e}")
        return False


def test_hypothesis_creation():
    """Test creating evolution hypothesis."""
    try:
        hypothesis = EvolutionHypothesis(
            hypothesis_id='test_hyp_001',
            domain='consciousness',
            hypothesis_type='optimization',
            description='Test hypothesis for consciousness acceleration',
            potential_impact=0.8,
            feasibility=0.7,
            risk_level=0.2,
            supporting_evidence=['Evidence 1', 'Evidence 2'],
            test_plan={'method': 'test', 'duration': 24},
            created_at=time.time()
        )
        print("✅ Successfully created EvolutionHypothesis")
        print(f"   - Domain: {hypothesis.domain}")
        print(f"   - Impact: {hypothesis.potential_impact}")
        print(f"   - Feasibility: {hypothesis.feasibility}")
        return True
    except Exception as e:
        print(f"❌ Failed to create hypothesis: {e}")
        return False


def run_integration_tests():
    """Run all integration tests."""
    print("\n" + "="*60)
    print("Phase 6: Consciousness Evolution Platform Integration Tests")
    print("="*60 + "\n")
    
    tests = [
        ("Consciousness State Creation", test_consciousness_state_creation),
        ("Platform Initialization", test_platform_initialization),
        ("Guidance System Initialization", test_guidance_initialization),
        ("Dashboard Initialization", test_dashboard_initialization),
        ("Evolution Engine Initialization", test_evolution_engine_initialization),
        ("Consciousness Vector Encoding", test_consciousness_vector_encoding),
        ("Evolution Hypothesis Creation", test_hypothesis_creation)
    ]
    
    passed = 0
    failed = 0
    
    for test_name, test_func in tests:
        print(f"\nTesting {test_name}...")
        print("-" * 40)
        if test_func():
            passed += 1
        else:
            failed += 1
    
    print("\n" + "="*60)
    print(f"Test Results: {passed} passed, {failed} failed")
    print(f"Success Rate: {(passed/(passed+failed)*100):.1f}%")
    print("="*60)
    
    if failed == 0:
        print("\n✨ All Phase 6 integration tests passed! ✨")
        print("The Consciousness Evolution Platform is ready for deployment.")
    else:
        print(f"\n⚠️  {failed} tests failed. Please review the errors above.")


if __name__ == "__main__":
    run_integration_tests()