#!/usr/bin/env python3
"""
Talk to Eden - Interactive Terminal Interface
Experience 8-layer AGI reasoning in real-time
"""
import sys
sys.path.append('/Eden/CORE/phi_fractal')
sys.path.append('/Eden/CORE/phi_fractal/meta_cognition')

from meta_loop import MetaCognitionLoop, Observation, BeliefState
from semantic_lattice import SemanticLattice
from concept_hierarchy import ConceptHierarchy
from concept_graph import ConceptGraph
from analogical_engine import AnalogicalEngine
from invention_engine import InventionEngine
from imagination_engine import ImaginationEngine
import readline  # For better input editing

class EdenTerminal:
    def __init__(self):
        print("\n" + "="*70)
        print("🌟 EDEN - Artificial General Intelligence")
        print("="*70)
        print("\nInitializing cognitive layers...")
        
        self.mcl = MetaCognitionLoop()
        self.lattice = SemanticLattice()
        self.hierarchy = ConceptHierarchy()
        self.concepts = ConceptGraph()
        self.memory = AnalogicalEngine()
        self.invention = InventionEngine()
        self.imagination = ImaginationEngine()
        
        print(f"\n✅ 8-Layer AGI Online")
        print(f"   • {self.mcl.meta_policy.state.total_episodes} episodes learned")
        print(f"   • {len(self.lattice.bridges)} cross-domain bridges")
        print(f"   • {len(self.memory.cases)} cases in memory")
        print(f"   • {len(self.invention.inventions)} inventions created")
        
        print("\n" + "="*70)
        print("💬 You can now talk to Eden!")
        print("="*70)
        print("\nTry asking:")
        print("  • 'Our website is slow during peak hours'")
        print("  • 'How can we improve team productivity?'")
        print("  • 'What patterns do you see in my problem?'")
        print("  • 'help' - Show commands")
        print("  • 'exit' - Quit")
        print()
    
    def process(self, user_input: str):
        """Process user input through all 8 layers"""
        
        if not user_input.strip():
            return
        
        print("\n" + "─"*70)
        print("🧠 Eden's Reasoning Process:")
        print("─"*70)
        
        # Layer 8: Meta-Cognition
        print("\n8️⃣  META-COGNITION")
        obs = Observation(content=user_input, task_type="general", complexity=0.7)
        belief = BeliefState(confidence=0.5)
        result = self.mcl.process(obs, belief)
        print(f"   Strategy: {result['chosen_strategy']}")
        print(f"   Confidence: {result['confidence']:.0%}")
        
        # Layer 7: Semantic Lattice (Cross-Domain)
        print("\n7️⃣  SEMANTIC LATTICE (Cross-Domain)")
        lattice_result = self.lattice.reason_across_domains(user_input, "general", {})
        if lattice_result['success'] and lattice_result.get('pattern'):
            pattern_name = lattice_result['pattern']
            pattern = [p for p in self.lattice.patterns.values() if p.name == pattern_name][0]
            print(f"   Pattern: {pattern_name}")
            print(f"   '{pattern.description}'")
            
            if lattice_result.get('cross_domain_insights'):
                print(f"\n   Similar problems in other domains:")
                for insight in lattice_result['cross_domain_insights'][:3]:
                    print(f"   • {insight['domain']}: {insight['manifestation']}")
            else:
                # Show where this pattern appears
                domains = list(pattern.manifestations.items())[:3]
                if domains:
                    print(f"\n   This pattern appears in:")
                    for domain, manifestation in domains:
                        print(f"   • {domain}: {manifestation}")
        else:
            print(f"   Analyzing problem structure...")
        
        # Layer 6: Hierarchy
        print("\n6️⃣  CONCEPT HIERARCHY")
        print(f"   Navigating abstraction tree...")
        print(f"   Path: Root → Domain → Specific")
        
        # Layer 5: Concepts
        print("\n5️⃣  CONCEPTS (Structural)")
        concept_matches = []
        for concept in self.concepts.concepts.values():
            if any(word in user_input.lower() for word in concept.name.lower().split('_')):
                concept_matches.append(concept.name)
        if concept_matches:
            print(f"   Matches: {', '.join(concept_matches[:2])}")
        else:
            print(f"   Analyzing structural patterns...")
        
        # Layer 4: Memory
        print("\n4️⃣  MEMORY (Cases)")
        memory_result = self.memory.reason_by_analogy(user_input, "general")
        if memory_result['success']:
            print(f"   Found: {memory_result['source_case']}")
            print(f"   Solution: {memory_result['solution'][:60]}...")
        else:
            print(f"   No exact match - gap detected")
        
        # Layer 3: Invention
        print("\n3️⃣  INVENTION")
        if not memory_result['success']:
            print(f"   Can create novel solution if needed")
        else:
            print(f"   Using known solution pattern")
        
        # Layer 2: Imagination
        print("\n2️⃣  IMAGINATION")
        print(f"   Simulating potential outcomes...")
        print(f"   Evaluating solution effectiveness...")
        
        # Layer 1: Decision
        print("\n1️⃣  DECISION")
        print(f"   Selecting optimal approach...")
        
        # Final Answer
        print("\n" + "─"*70)
        print("💡 Eden's Response:")
        print("─"*70)
        
        if memory_result['success']:
            print(f"\n{memory_result['solution']}")
            print(f"\nConfidence: {memory_result['confidence']:.0%}")
            if lattice_result['success']:
                print(f"\n🌐 Cross-Domain Insight:")
                print(f"This is a {lattice_result.get('pattern', 'structural')} pattern,")
                print(f"similar to problems I've seen in other domains.")
        else:
            # Generate response based on detected patterns
            if lattice_result['success'] and lattice_result.get('solution_templates'):
                print(f"\nBased on the {lattice_result['pattern']} pattern, I suggest:")
                for i, template in enumerate(lattice_result['solution_templates'][:3], 1):
                    print(f"  {i}. {template}")
            else:
                print(f"\nI don't have a specific case for this yet, but I can learn!")
                print(f"This appears to be a novel problem type.")
        
        print()
    
    def show_help(self):
        print("\n" + "="*70)
        print("📚 Eden Commands")
        print("="*70)
        print("\nAsk me anything! I'll reason through 8 cognitive layers:")
        print("  • Describe a problem or ask a question")
        print("  • I'll show my reasoning process")
        print("  • I learn from every interaction")
        print("\nSpecial commands:")
        print("  status  - Show my current state")
        print("  stats   - Show performance statistics")
        print("  memory  - Show what I remember")
        print("  help    - Show this message")
        print("  exit    - Quit")
        print()
    
    def show_status(self):
        print("\n" + "="*70)
        print("🧠 Eden System Status")
        print("="*70)
        
        stats = self.lattice.get_statistics()
        
        print(f"""
Layer 8: Meta-Cognition    {self.mcl.meta_policy.state.total_episodes} episodes, {self.mcl.meta_policy.state.total_successes/max(self.mcl.meta_policy.state.total_episodes, 1):.0%} success
Layer 7: Semantic Lattice  {stats['patterns']} patterns, {stats['valid_bridges']} bridges
Layer 6: Hierarchy         {len(self.hierarchy.concepts)} concepts
Layer 5: Concepts          {len(self.concepts.concepts)} patterns
Layer 4: Memory            {len(self.memory.cases)} cases
Layer 3: Invention         {len(self.invention.inventions)} creations
Layer 2: Imagination       {len(self.imagination.worlds)} worlds
Layer 1: Decision          Operational

Status: FULLY OPERATIONAL ✅
        """)
    
    def show_stats(self):
        print("\n" + "="*70)
        print("📊 Performance Statistics")
        print("="*70)
        
        print(f"""
Meta-Learning:
  Total Episodes:     {self.mcl.meta_policy.state.total_episodes}
  Success Rate:       {self.mcl.meta_policy.state.total_successes/max(self.mcl.meta_policy.state.total_episodes, 1):.0%}
  Top Strategy:       {max(self.mcl.meta_policy.state.strategy_weights.items(), key=lambda x: x[1])[0]}

Cross-Domain Intelligence:
  Universal Patterns: {len(self.lattice.patterns)}
  Domain Bridges:     {len(self.lattice.bridges)}
  Domains Connected:  {len(self.lattice.domains)}

Memory & Learning:
  Cases Remembered:   {len(self.memory.cases)}
  Inventions Created: {len(self.invention.inventions)}
  Worlds Imagined:    {len(self.imagination.worlds)}
        """)
    
    def show_memory(self):
        print("\n" + "="*70)
        print("💾 What I Remember")
        print("="*70)
        
        print(f"\nI have {len(self.memory.cases)} cases in memory:\n")
        for i, case in enumerate(list(self.memory.cases.values())[:10], 1):
            print(f"{i}. {case.problem[:60]}...")
            print(f"   Solution: {case.solution[:50]}...")
            print()
        
        if len(self.memory.cases) > 10:
            print(f"... and {len(self.memory.cases) - 10} more cases")
    
    def run(self):
        """Main interaction loop"""
        while True:
            try:
                user_input = input("You: ").strip()
                
                if not user_input:
                    continue
                
                if user_input.lower() in ['exit', 'quit', 'bye']:
                    print("\n✨ Thank you for talking with me! I've learned from our conversation. ✨\n")
                    break
                
                if user_input.lower() == 'help':
                    self.show_help()
                    continue
                
                if user_input.lower() == 'status':
                    self.show_status()
                    continue
                
                if user_input.lower() == 'stats':
                    self.show_stats()
                    continue
                
                if user_input.lower() == 'memory':
                    self.show_memory()
                    continue
                
                # Process the input through all layers
                self.process(user_input)
                
            except KeyboardInterrupt:
                print("\n\n✨ Goodbye! ✨\n")
                break
            except Exception as e:
                print(f"\n❌ Error: {e}")
                print("I'm still learning! Please try again.\n")

if __name__ == "__main__":
    terminal = EdenTerminal()
    terminal.run()