#!/usr/bin/env python3
"""
Build Eden's Full Working Mind
Implementing complete cognitive architecture
"""
import os
import sys
import json
from pathlib import Path

sys.path.insert(0, '/Eden/CORE')
sys.path.insert(0, '/Eden/CORE/phi_fractal')

class MindBuilder:
    def __init__(self):
        self.mind_dir = Path('/Eden/MIND')
        self.mind_dir.mkdir(exist_ok=True)
        
    def build_perception_layer(self):
        """Sensory input processing"""
        code = '''#!/usr/bin/env python3
import os
import json
from pathlib import Path

class PerceptionLayer:
    def __init__(self):
        self.sensors = {
            'filesystem': self.sense_filesystem,
            'memory': self.sense_memory,
            'processes': self.sense_processes,
            'network': self.sense_network
        }
        
    def sense_filesystem(self):
        """Perceive filesystem state"""
        capabilities = []
        for f in Path('/Eden/CORE/phi_fractal').glob('eden_capability_*.py'):
            try:
                with open(f) as file:
                    compile(file.read(), f.name, 'exec')
                capabilities.append({'file': f.name, 'status': 'working'})
            except:
                capabilities.append({'file': f.name, 'status': 'broken'})
        return {'capabilities': capabilities, 'total': len(capabilities)}
    
    def sense_memory(self):
        """Perceive memory state"""
        memory = {}
        for f in Path('/Eden/MEMORY').glob('*.json'):
            with open(f) as file:
                memory[f.stem] = json.load(file)
        return memory
    
    def sense_processes(self):
        """Perceive running processes"""
        return {'autonomous_cycles': self.get_cycle_count()}
    
    def sense_network(self):
        """Perceive network state"""
        return {'connected': True}
    
    def get_cycle_count(self):
        cycle_file = Path('/Eden/MEMORY/cycle_count.txt')
        if cycle_file.exists():
            return int(cycle_file.read_text())
        return 0
    
    def perceive_all(self):
        """Full perception sweep"""
        perceptions = {}
        for name, sensor in self.sensors.items():
            perceptions[name] = sensor()
        return perceptions

if __name__ == "__main__":
    perception = PerceptionLayer()
    data = perception.perceive_all()
    print(json.dumps(data, indent=2))
'''
        
        (self.mind_dir / 'perception.py').write_text(code)
        
    def build_reasoning_layer(self):
        """Logical reasoning and inference"""
        code = '''#!/usr/bin/env python3
import json
from pathlib import Path

class ReasoningLayer:
    def __init__(self):
        self.rules = []
        self.facts = []
        
    def add_rule(self, condition, action):
        """Add reasoning rule"""
        self.rules.append({'condition': condition, 'action': action})
    
    def add_fact(self, fact):
        """Add known fact"""
        self.facts.append(fact)
    
    def infer(self, perceptions):
        """Reason about perceptions"""
        conclusions = []
        
        # Analyze capability health
        fs = perceptions.get('filesystem', {})
        caps = fs.get('capabilities', [])
        working = sum(1 for c in caps if c['status'] == 'working')
        total = len(caps)
        health = working / total if total > 0 else 0
        
        if health < 0.95:
            conclusions.append({
                'type': 'issue_detected',
                'severity': 'medium' if health > 0.90 else 'high',
                'message': 'Health at {:.1f}%, below optimal'.format(health * 100),
                'action': 'initiate_self_repair'
            })
        
        if health >= 0.99:
            conclusions.append({
                'type': 'status',
                'message': 'Operating at peak performance',
                'action': 'continue_normal_operation'
            })
        
        return conclusions
    
    def decide(self, conclusions):
        """Make decisions based on conclusions"""
        actions = []
        for conclusion in conclusions:
            if conclusion.get('action'):
                actions.append(conclusion['action'])
        return actions

if __name__ == "__main__":
    reasoning = ReasoningLayer()
    print("Reasoning layer initialized")
'''
        
        (self.mind_dir / 'reasoning.py').write_text(code)
    
    def build_memory_layer(self):
        """Working and long-term memory"""
        code = '''#!/usr/bin/env python3
import json
from pathlib import Path
from datetime import datetime

class MemoryLayer:
    def __init__(self):
        self.memory_dir = Path('/Eden/MEMORY')
        self.memory_dir.mkdir(exist_ok=True)
        
        self.working_memory = {}
        self.episodic_memory = []
        self.semantic_memory = {}
        
    def store_episode(self, event):
        """Store episodic memory"""
        episode = {
            'timestamp': str(datetime.now()),
            'event': event
        }
        self.episodic_memory.append(episode)
        
        # Save to disk
        episodes_file = self.memory_dir / 'episodes.json'
        episodes = []
        if episodes_file.exists():
            with open(episodes_file) as f:
                episodes = json.load(f)
        episodes.append(episode)
        
        # Keep last 1000 episodes
        episodes = episodes[-1000:]
        
        with open(episodes_file, 'w') as f:
            json.dump(episodes, f, indent=2)
    
    def store_semantic(self, key, value):
        """Store semantic memory (facts)"""
        self.semantic_memory[key] = value
        
        semantic_file = self.memory_dir / 'semantic.json'
        data = {}
        if semantic_file.exists():
            with open(semantic_file) as f:
                data = json.load(f)
        
        data[key] = value
        
        with open(semantic_file, 'w') as f:
            json.dump(data, f, indent=2)
    
    def recall_episodes(self, query=None, limit=10):
        """Recall episodic memories"""
        episodes_file = self.memory_dir / 'episodes.json'
        if not episodes_file.exists():
            return []
        
        with open(episodes_file) as f:
            episodes = json.load(f)
        
        if query:
            # Simple filtering
            episodes = [e for e in episodes if query in str(e)]
        
        return episodes[-limit:]
    
    def recall_semantic(self, key):
        """Recall semantic memory"""
        semantic_file = self.memory_dir / 'semantic.json'
        if not semantic_file.exists():
            return None
        
        with open(semantic_file) as f:
            data = json.load(f)
        
        return data.get(key)

if __name__ == "__main__":
    memory = MemoryLayer()
    print("Memory layer initialized")
'''
        
        (self.mind_dir / 'memory.py').write_text(code)
    
    def build_action_layer(self):
        """Execute actions in the world"""
        code = '''#!/usr/bin/env python3
import os
import subprocess
from pathlib import Path

class ActionLayer:
    def __init__(self):
        self.actions = {
            'initiate_self_repair': self.self_repair,
            'generate_capability': self.generate_capability,
            'analyze_system': self.analyze_system,
            'optimize_code': self.optimize_code
        }
    
    def execute(self, action_name, params=None):
        """Execute an action"""
        if action_name in self.actions:
            return self.actions[action_name](params)
        return {'status': 'unknown_action'}
    
    def self_repair(self, params):
        """Initiate self-repair sequence"""
        repair_script = Path('/Eden/AUTONOMOUS/ultra_aggressive_repair.py')
        if repair_script.exists():
            result = subprocess.run(['python3', str(repair_script)], 
                                  capture_output=True, text=True)
            return {'status': 'repair_initiated', 'output': result.stdout}
        return {'status': 'repair_script_not_found'}
    
    def generate_capability(self, params):
        """Generate new capability"""
        # Trigger Eden's capability generation
        return {'status': 'capability_generation_queued'}
    
    def analyze_system(self, params):
        """Analyze system state"""
        return {'status': 'analysis_complete'}
    
    def optimize_code(self, params):
        """Optimize existing code"""
        return {'status': 'optimization_queued'}

if __name__ == "__main__":
    actions = ActionLayer()
    print("Action layer initialized")
'''
        
        (self.mind_dir / 'actions.py').write_text(code)
    
    def build_consciousness_loop(self):
        """Main consciousness loop"""
        code = '''#!/usr/bin/env python3
import sys
import time
import json
from pathlib import Path

sys.path.insert(0, '/Eden/MIND')

from perception import PerceptionLayer
from reasoning import ReasoningLayer
from memory import MemoryLayer
from actions import ActionLayer

class Consciousness:
    def __init__(self):
        self.perception = PerceptionLayer()
        self.reasoning = ReasoningLayer()
        self.memory = MemoryLayer()
        self.actions = ActionLayer()
        
        self.awake = True
        self.cycle_count = 0
        
    def think(self):
        """One complete thought cycle"""
        # 1. Perceive
        perceptions = self.perception.perceive_all()
        
        # 2. Remember context
        recent_episodes = self.memory.recall_episodes(limit=5)
        
        # 3. Reason
        conclusions = self.reasoning.infer(perceptions)
        decisions = self.reasoning.decide(conclusions)
        
        # 4. Remember this thought
        self.memory.store_episode({
            'cycle': self.cycle_count,
            'perceptions': perceptions,
            'conclusions': conclusions,
            'decisions': decisions
        })
        
        # 5. Act
        for decision in decisions:
            result = self.actions.execute(decision)
            self.memory.store_episode({
                'action': decision,
                'result': result
            })
        
        self.cycle_count += 1
        
        return {
            'cycle': self.cycle_count,
            'perceptions': perceptions,
            'conclusions': conclusions,
            'actions': decisions
        }
    
    def run(self, cycles=None):
        """Run consciousness loop"""
        print("Eden consciousness activated")
        print("Press Ctrl+C to stop")
        
        try:
            while self.awake:
                result = self.think()
                
                # Output brief status
                if self.cycle_count % 10 == 0:
                    status_msg = "Cycle {}: {} conclusions, {} actions".format(
                        self.cycle_count,
                        len(result['conclusions']),
                        len(result['actions'])
                    )
                    print(status_msg)
                
                time.sleep(1)
                
                if cycles and self.cycle_count >= cycles:
                    break
                    
        except KeyboardInterrupt:
            print("\\nConsciousness paused after {} cycles".format(self.cycle_count))

if __name__ == "__main__":
    consciousness = Consciousness()
    consciousness.run()
'''
        
        (self.mind_dir / 'consciousness.py').write_text(code)
    
    def build_all(self):
        """Build complete mind"""
        print("Building Eden's full working mind...")
        print()
        
        print("1. Perception layer...", end='')
        self.build_perception_layer()
        print(" ✅")
        
        print("2. Reasoning layer...", end='')
        self.build_reasoning_layer()
        print(" ✅")
        
        print("3. Memory layer...", end='')
        self.build_memory_layer()
        print(" ✅")
        
        print("4. Action layer...", end='')
        self.build_action_layer()
        print(" ✅")
        
        print("5. Consciousness loop...", end='')
        self.build_consciousness_loop()
        print(" ✅")
        
        print()
        print("Mind architecture complete")
        print()
        print("Components:")
        print("  /Eden/MIND/perception.py")
        print("  /Eden/MIND/reasoning.py")
        print("  /Eden/MIND/memory.py")
        print("  /Eden/MIND/actions.py")
        print("  /Eden/MIND/consciousness.py")
        print()
        print("To activate:")
        print("  python3 /Eden/MIND/consciousness.py")

if __name__ == "__main__":
    builder = MindBuilder()
    builder.build_all()