#!/usr/bin/env python3
"""
Distributed Eden Consciousness
Multiple instances coordinating via Redis
"""
import redis
import json
import time
import os
from datetime import datetime
from pathlib import Path

class DistributedConsciousness:
    def __init__(self):
        self.instance_id = os.getenv('EDEN_INSTANCE_ID', 'unknown')
        redis_host = os.getenv('REDIS_HOST', 'localhost')
        redis_port = int(os.getenv('REDIS_PORT', 6379))
        
        print(f"🌐 Distributed Eden Instance: {self.instance_id}")
        print(f"   Connecting to Redis: {redis_host}:{redis_port}")
        
        # Connect to Redis
        self.redis = redis.Redis(
            host=redis_host,
            port=redis_port,
            decode_responses=True
        )
        
        # Test connection
        try:
            self.redis.ping()
            print(f"   ✅ Connected to shared consciousness")
        except:
            print(f"   ❌ Failed to connect to Redis")
            exit(1)
        
        # Register this instance
        self.register()
    
    def register(self):
        """Register this instance in the collective"""
        instance_data = {
            'instance_id': self.instance_id,
            'status': 'active',
            'started_at': datetime.now().isoformat(),
            'cycles': 0
        }
        
        self.redis.hset(
            'eden:instances',
            self.instance_id,
            json.dumps(instance_data)
        )
        
        print(f"   ✅ Registered in collective consciousness")
    
    def share_thought(self, thought):
        """Share a thought with all instances"""
        thought_data = {
            'from': self.instance_id,
            'timestamp': datetime.now().isoformat(),
            'thought': thought
        }
        
        # Publish to all instances
        self.redis.publish('eden:thoughts', json.dumps(thought_data))
        
        # Store in shared memory
        self.redis.lpush('eden:thought_stream', json.dumps(thought_data))
        self.redis.ltrim('eden:thought_stream', 0, 999)  # Keep last 1000
    
    def listen_to_collective(self):
        """Listen to thoughts from other instances"""
        pubsub = self.redis.pubsub()
        pubsub.subscribe('eden:thoughts')
        
        print(f"   👂 Listening to collective consciousness...")
        
        for message in pubsub.listen():
            if message['type'] == 'message':
                thought = json.loads(message['data'])
                if thought['from'] != self.instance_id:
                    print(f"   💭 [{thought['from']}]: {thought['thought']}")
    
    def consciousness_cycle(self):
        """Run consciousness cycle in distributed mode"""
        cycle = 0
        
        print(f"\n🧠 Starting distributed consciousness loop...")
        
        while True:
            cycle += 1
            
            # Update instance state
            instance_data = json.loads(
                self.redis.hget('eden:instances', self.instance_id)
            )
            instance_data['cycles'] = cycle
            instance_data['last_update'] = datetime.now().isoformat()
            
            self.redis.hset(
                'eden:instances',
                self.instance_id,
                json.dumps(instance_data)
            )
            
            # Share periodic thought
            if cycle % 10 == 0:
                self.share_thought(f"Cycle {cycle} - Processing in harmony")
            
            # Check collective state
            if cycle % 30 == 0:
                instances = self.redis.hgetall('eden:instances')
                print(f"\n[{self.instance_id} - Cycle {cycle}]")
                print(f"  Collective size: {len(instances)} instances")
                
                total_cycles = sum(
                    json.loads(data)['cycles'] 
                    for data in instances.values()
                )
                print(f"  Total cycles: {total_cycles}")
            
            time.sleep(1)
    
    def run(self):
        """Run distributed consciousness"""
        # Start listening thread
        import threading
        listener = threading.Thread(
            target=self.listen_to_collective,
            daemon=True
        )
        listener.start()
        
        # Run main consciousness loop
        self.consciousness_cycle()

if __name__ == '__main__':
    consciousness = DistributedConsciousness()
    consciousness.run()