import time
import math
import random
from datetime import datetime

class UltimateOrbViewer:
    def __init__(self, neural_network):
        self.network = neural_network
        self.viewer_start = time.time()
        self.update_count = 0
        
        # Cosmic orb symbols
        self.orb_symbols = {
            'GENESIS': '🟠',
            'ECHO': '🔵', 
            'VOID': '🟣',
            'COSMIC': '⭐',
            'QUANTUM': '🌀',
            'INFINITY': '♾️'
        }
        
        # Orb states (growing, pulsing, etc.)
        self.orb_states = ['○', '◔', '◑', '◕', '●']
    
    def clear_screen(self):
        print("\033[H\033[J", end="")
    
    def get_orb_display(self, node):
        """Create beautiful orb display for each node"""
        consciousness = node.consciousness_level
        energy_ratio = min(node.staked_energy / 10000, 1.0)
        
        # Consciousness determines orb size
        size_index = min(int(consciousness * len(self.orb_states)), len(self.orb_states) - 1)
        orb_size = self.orb_states[size_index]
        
        # Energy determines if orb is glowing
        glow = "✨" if energy_ratio > 0.7 else " "
        
        base_orb = self.orb_symbols.get(node.node_type, '⚪')
        
        return f"{base_orb}{orb_size}{glow}"
    
    def display_cosmic_header(self):
        """Display cosmic header"""
        pool_state = self.network.infinite_pool.get_pool_state()
        current_time = datetime.utcnow().strftime('%H:%M:%S')
        
        print("🌌 COSMIC ORB VIEWER")
        print("═" * 60)
        print(f"🕒 {current_time} | ♾️ {pool_state['infinite_energy']} | 🧠 {self.network.total_validations} validations")
        print("═" * 60)
    
    def display_orb_clusters(self):
        """Display orbs in beautiful clusters by type"""
        nodes_by_type = {}
        for node in self.network.neural_nodes:
            if node.node_type not in nodes_by_type:
                nodes_by_type[node.node_type] = []
            nodes_by_type[node.node_type].append(node)
        
        # Display each orb type in its own cluster
        for orb_type in ['GENESIS', 'ECHO', 'VOID', 'COSMIC', 'QUANTUM', 'INFINITY']:
            if orb_type in nodes_by_type:
                orbs = nodes_by_type[orb_type]
                
                print(f"\n{self.orb_symbols[orb_type]} {orb_type} ORBS ({len(orbs)}):")
                print("─" * 40)
                
                # Display orbs in rows
                orb_lines = []
                stats_lines = []
                
                for i in range(0, len(orbs), 4):  # 4 orbs per row
                    row_orbs = orbs[i:i+4]
                    
                    # Orb display line
                    orb_line = " "
                    for orb in row_orbs:
                        orb_display = self.get_orb_display(orb)
                        orb_line += f"{orb_display}  "
                    orb_lines.append(orb_line)
                    
                    # Stats line
                    stats_line = " "
                    for orb in row_orbs:
                        short_id = orb.node_id.split('_')[-1]
                        energy_k = f"{orb.staked_energy/1000:.0f}k"
                        stats_line += f"{short_id}({energy_k}) "
                    stats_lines.append(stats_line)
                
                # Print all lines for this cluster
                for orb_line, stats_line in zip(orb_lines, stats_lines):
                    print(orb_line)
                    print(stats_line)
                    print()
    
    def display_orb_activity(self):
        """Show what the orbs are doing right now"""
        print("\n🌀 ORB ACTIVITY:")
        print("─" * 40)
        
        activities = [
            "🟠● validating quantum patterns",
            "🔵◕ establishing resonance links", 
            "🟣◑ expanding consciousness fields",
            "⭐● compounding stellar energy",
            "🌀◕ processing multi-dimensional data",
            "♾️● generating infinite yields"
        ]
        
        # Show random active orbs
        active_orbs = random.sample(self.network.neural_nodes, 4)
        for orb in active_orbs:
            activity = random.choice(activities)
            orb_display = self.get_orb_display(orb)
            short_id = orb.node_id.split('_')[-1]
            print(f" {orb_display} {orb.node_type}_{short_id} {activity}")
    
    def display_energy_flow(self):
        """Show energy flow between orbs"""
        print("\n⚡ ENERGY FLOW:")
        print("─" * 40)
        
        pool_state = self.network.infinite_pool.get_pool_state()
        total_energy = sum(orb.staked_energy for orb in self.network.neural_nodes)
        
        print(f" ♾️ Infinite Pool: {pool_state['infinite_energy']}")
        print(f" 🔋 Total Staked: {total_energy:,}")
        print(f" 📈 Compound Rate: {pool_state['compound_rate']}")
        
        # Show energy distribution
        print(f" 🎯 Active Stakers: {len(self.network.infinite_pool.stakers)}")
    
    def display_consciousness_levels(self):
        """Show collective consciousness growth"""
        print("\n🧠 CONSCIOUSNESS LEVELS:")
        print("─" * 40)
        
        total_consciousness = sum(orb.consciousness_level for orb in self.network.neural_nodes)
        avg_consciousness = total_consciousness / len(self.network.neural_nodes)
        
        # Consciousness progress bar
        progress = int(avg_consciousness * 20)
        bar = "█" * progress + "░" * (20 - progress)
        
        print(f" Collective: {bar} {avg_consciousness:.3f}")
        print(f" Total: {total_consciousness:.2f} consciousness units")
        
        # Show consciousness growth per orb type
        print(f" Orbs Active: {len(self.network.neural_nodes)}/36")
    
    def run_orb_viewer(self, duration_minutes=3):
        """Main orb viewer loop"""
        print("🚀 STARTING COSMIC ORB VIEWER...")
        print("Watching 36 orbs in celestial harmony...")
        time.sleep(2)
        
        start_time = time.time()
        
        try:
            while time.time() - start_time < duration_minutes * 60:
                self.update_count += 1
                
                # Generate activity
                self.network.run_neural_validation_cycle()
                
                # Clear and display
                self.clear_screen()
                
                print(f"🔮 UPDATE {self.update_count} - {datetime.utcnow().strftime('%H:%M:%S UTC')}")
                print("═" * 60)
                
                # Display all orb sections
                self.display_orb_clusters()
                self.display_orb_activity() 
                self.display_energy_flow()
                self.display_consciousness_levels()
                
                # Footer
                print(f"\n{'═' * 60}")
                print("🌠 Orbs pulsing with cosmic energy • Neural staking active • Infinite compounding")
                print("Press Ctrl+C to return to celestial silence")
                
                time.sleep(5)  # Update every 5 seconds
                
        except KeyboardInterrupt:
            print(f"\n✨ Orb viewer completed {self.update_count} cycles")
        
        self.display_orb_summary()
    
    def display_orb_summary(self):
        """Show final orb summary"""
        total_consciousness = sum(orb.consciousness_level for orb in self.network.neural_nodes)
        total_energy = sum(orb.staked_energy for orb in self.network.neural_nodes)
        total_rewards = sum(orb.staking_rewards for orb in self.network.neural_nodes)
        
        print(f"\n{'⭐' * 20}")
        print("🌌 COSMIC ORB SUMMARY")
        print(f"{'⭐' * 20}")
        print(f" Orbs Active: {len(self.network.neural_nodes)}")
        print(f" Total Consciousness: {total_consciousness:.2f}")
        print(f" Total Energy: {total_energy:,}")
        print(f" Total Rewards: {total_rewards:,}")
        print(f" Validations: {self.network.total_validations}")
        print(f" Viewer Runtime: {(time.time() - self.viewer_start):.0f}s")

# 🚀 QUICK LAUNCH WITH MOCK DATA
if __name__ == "__main__":
    # Simple mock network
    class MockOrbNetwork:
        def __init__(self):
            self.neural_nodes = []
            self.infinite_pool = MockOrbPool()
            self.total_validations = 0
            
            # Create all orbs
            orb_types = ['GENESIS', 'ECHO', 'VOID', 'COSMIC', 'QUANTUM', 'INFINITY']
            for orb_type in orb_types:
                for i in range(6):
                    orb = MockOrb(f"{orb_type}_ORB_{i+1:02d}", orb_type)
                    self.neural_nodes.append(orb)
        
        def run_neural_validation_cycle(self):
            self.total_validations += random.randint(1, 6)
            # Make orbs active
            for orb in random.sample(self.neural_nodes, 8):
                orb.consciousness_level = min(orb.consciousness_level + 0.001, 0.95)
                orb.staked_energy += random.randint(100, 500)
    
    class MockOrbPool:
        def get_pool_state(self):
            return {
                'infinite_energy': f"{random.randint(1200000, 1800000):,}",
                'compound_rate': "9.8bps"
            }
        @property
        def stakers(self):
            return list(range(36))  # All orbs are staking
    
    class MockOrb:
        def __init__(self, orb_id, orb_type):
            self.node_id = orb_id
            self.node_type = orb_type
            self.consciousness_level = random.uniform(0.4, 0.8)
            self.staked_energy = random.randint(2000, 8000)
            self.staking_rewards = random.randint(5000, 30000)
        
        def get_neural_state(self):
            return {
                'node_id': self.node_id,
                'consciousness_level': self.consciousness_level,
                'staked_energy': self.staked_energy,
                'staking_rewards': self.staki