blockcode_simulator.py

"""Blockcode NFT Simulator - Interactive tesseract visualization and simulation."""

import time
import random
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime
from blockcode_nft_client import get_blockcode_nft_client
from network_nft_bridge import create_network_nft_bridge


class BlockcodeSimulator:
    """Interactive simulator for blockcode NFT system."""
    
    def __init__(self):
        """Initialize the simulator."""
        self.client = get_blockcode_nft_client(
            tesseract_id="simulator",
            local_vertex=[0, 0, 0, 0]
        )
        self.network_bridge = create_network_nft_bridge("simulator-network")
        
        # Simulation state
        self.running = False
        self.step_count = 0
        self.events = []
        
        print("\n" + "="*80)
        print("Blockcode NFT Simulator")
        print("="*80)
        print("✓ Tesseract initialized (16 vertices, 32 edges)")
        print("✓ Network bridge ready")
        print("="*80 + "\n")
    
    def visualize_tesseract(self, highlight_vertices: List[List[int]] = None):
        """Visualize the tesseract with NFTs."""
        highlight_vertices = highlight_vertices or []
        
        print("\n" + "┌" + "─"*78 + "┐")
        print("│" + " "*25 + "TESSERACT VISUALIZATION" + " "*30 + "│")
        print("└" + "─"*78 + "┘")
        
        # Get all NFTs
        all_nfts = self.client.list_all_nfts()
        nft_map = {tuple(nft['vertex']): nft for nft in all_nfts}
        
        # Draw tesseract layers
        print("\nInner Cube (t=0):                    Outer Cube (t=1):")
        print("-"*80)
        
        for z in [0, 1]:
            print(f"\n  z={z} layer:\n")
            
            # t=0 cube
            for y in [0, 1]:
                line_t0 = "    "
                for x in [0, 1]:
                    vertex = [x, y, z, 0]
                    vertex_tuple = tuple(vertex)
                    
                    if vertex_tuple in nft_map:
                        symbol = "●"  # NFT present
                        if vertex in highlight_vertices:
                            symbol = "◉"  # Highlighted NFT
                    else:
                        symbol = "○"  # Empty vertex
                    
                    coord = f"[{x},{y},{z},0]"
                    line_t0 += f"{symbol} {coord:12s}  "
                
                # t=1 cube
                line_t1 = "    "
                for x in [0, 1]:
                    vertex = [x, y, z, 1]
                    vertex_tuple = tuple(vertex)
                    
                    if vertex_tuple in nft_map:
                        symbol = "●"
                        if vertex in highlight_vertices:
                            symbol = "◉"
                    else:
                        symbol = "○"
                    
                    coord = f"[{x},{y},{z},1]"
                    line_t1 += f"{symbol} {coord:12s}  "
                
                print(line_t0 + "  " + line_t1)
        
        # Legend
        print("\n" + "-"*80)
        print("Legend: ○ Empty   ● NFT Present   ◉ Highlighted")
        
        # NFT list
        if all_nfts:
            print("\nNFTs in Tesseract:")
            for nft in all_nfts:
                print(f"  • {nft['pattern_code']:20s} at {nft['vertex']}")
        else:
            print("\nNo NFTs in tesseract")
        
        print()
    
    def simulate_step(self, event_type: str = "random") -> Dict[str, Any]:
        """Simulate one step of the system.
        
        Args:
            event_type: Type of event to simulate (random, wifi, scan, peer, etc.)
            
        Returns:
            Step result dictionary
        """
        self.step_count += 1
        
        if event_type == "random":
            event_type = random.choice([
                "wifi_connect", "wifi_disconnect", 
                "network_scan", "peer_join",
                "mint_nft"
            ])
        
        result = {
            "step": self.step_count,
            "event": event_type,
            "timestamp": datetime.now().isoformat(),
            "changes": []
        }
        
        print(f"\n{'='*80}")
        print(f"STEP {self.step_count}: {event_type.upper().replace('_', ' ')}")
        print(f"{'='*80}")
        
        # Execute event
        if event_type == "mint_nft":
            result.update(self._simulate_mint())
        elif event_type == "wifi_connect":
            result.update(self._simulate_wifi_event("connect"))
        elif event_type == "wifi_disconnect":
            result.update(self._simulate_wifi_event("disconnect"))
        elif event_type == "network_scan":
            result.update(self._simulate_network_scan())
        elif event_type == "peer_join":
            result.update(self._simulate_peer_join())
        
        self.events.append(result)
        
        # Show changes
        if result.get("changes"):
            print("\nChanges:")
            for change in result["changes"]:
                print(f"  {change}")
        
        return result
    
    def _simulate_mint(self) -> Dict[str, Any]:
        """Simulate minting an NFT."""
        # Random vertex
        vertex = [random.randint(0, 1) for _ in range(4)]
        
        # Generate pattern
        spatial = random.choice(self.client.SPATIAL_CODES)
        rhythm = random.choice(self.client.RHYTHM_CODES)
        structure = random.choice(self.client.STRUCTURE_CODES)
        transform = random.choice(self.client.TRANSFORM_CODES)
        pattern = f"{spatial}.{rhythm}.{structure}.{transform}"
        
        print(f"\nMinting NFT...")
        print(f"  Pattern: {pattern}")
        print(f"  Vertex: {vertex}")
        
        try:
            nft = self.client.mint_nft(
                pattern_code=pattern,
                vertex=vertex,
                owner_pattern="SIM.USER.F0",
                metadata={
                    "title": f"Simulated Track #{self.step_count}",
                    "simulated": True,
                    "step": self.step_count
                }
            )
            
            return {
                "success": True,
                "nft": nft,
                "changes": [f"✓ Minted {pattern} at {vertex}"]
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "changes": [f"✗ Mint failed: {e}"]
            }
    
    def _simulate_wifi_event(self, event: str) -> Dict[str, Any]:
        """Simulate WiFi connect/disconnect."""
        all_nfts = self.client.list_all_nfts()
        
        if not all_nfts:
            return {
                "success": False,
                "changes": ["No NFTs to evolve"]
            }
        
        # Pick random NFT
        nft = random.choice(all_nfts)
        pattern = nft['pattern_code']
        
        print(f"\nWiFi {event} event")
        print(f"  Evolving: {pattern}")
        
        try:
            evolved = self.network_bridge.evolve_nft_on_wifi_change(pattern, event)
            
            return {
                "success": True,
                "evolved_nft": evolved,
                "changes": [
                    f"✓ {pattern} evolved via T-edge",
                    f"  {nft['vertex']} → {evolved['vertex']}"
                ]
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "changes": [f"✗ Evolution failed: {e}"]
            }
    
    def _simulate_network_scan(self) -> Dict[str, Any]:
        """Simulate network scan completion."""
        all_nfts = self.client.list_all_nfts()
        
        if not all_nfts:
            return {
                "success": False,
                "changes": ["No NFTs to move"]
            }
        
        # Pick random NFT
        nft = random.choice(all_nfts)
        pattern = nft['pattern_code']
        current_vertex = nft['vertex']
        
        # Toggle X coordinate
        new_vertex = current_vertex.copy()
        new_vertex[0] = 1 if current_vertex[0] == 0 else 0
        
        print(f"\nNetwork scan completed")
        print(f"  Moving: {pattern}")
        print(f"  Path: {current_vertex} → {new_vertex}")
        
        try:
            transfer = self.client.transfer_nft(
                pattern_code=pattern,
                from_vertex=current_vertex,
                to_vertex=new_vertex,
                new_owner_pattern=nft['owner_pattern']
            )
            
            return {
                "success": True,
                "transfer": transfer,
                "changes": [
                    f"✓ {pattern} moved via X-edge",
                    f"  {current_vertex} → {new_vertex}"
                ]
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "changes": [f"✗ Transfer failed: {e}"]
            }
    
    def _simulate_peer_join(self) -> Dict[str, Any]:
        """Simulate peer joining network."""
        all_nfts = self.client.list_all_nfts()
        
        if not all_nfts:
            return {
                "success": False,
                "changes": ["No NFTs to move"]
            }
        
        # Pick random NFT
        nft = random.choice(all_nfts)
        pattern = nft['pattern_code']
        current_vertex = nft['vertex']
        
        # Toggle Y coordinate
        new_vertex = current_vertex.copy()
        new_vertex[1] = 1 if current_vertex[1] == 0 else 0
        
        print(f"\nPeer joined network")
        print(f"  Moving: {pattern}")
        print(f"  Path: {current_vertex} → {new_vertex}")
        
        try:
            transfer = self.client.transfer_nft(
                pattern_code=pattern,
                from_vertex=current_vertex,
                to_vertex=new_vertex,
                new_owner_pattern=nft['owner_pattern']
            )
            
            return {
                "success": True,
                "transfer": transfer,
                "changes": [
                    f"✓ {pattern} moved via Y-edge",
                    f"  {current_vertex} → {new_vertex}"
                ]
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e),
                "changes": [f"✗ Transfer failed: {e}"]
            }
    
    def run_simulation(self, steps: int = 10, delay: float = 1.0):
        """Run simulation for N steps.
        
        Args:
            steps: Number of steps to simulate
            delay: Delay between steps in seconds
        """
        print(f"\nStarting simulation: {steps} steps")
        print("Press Ctrl+C to stop\n")
        
        self.running = True
        
        try:
            for i in range(steps):
                if not self.running:
                    break
                
                # Simulate step
                self.simulate_step("random")
                
                # Visualize after each step
                self.visualize_tesseract()
                
                # Delay
                if i < steps - 1:
                    time.sleep(delay)
        
        except KeyboardInterrupt:
            print("\n\nSimulation interrupted")
            self.running = False
        
        # Final stats
        self.show_statistics()
    
    def interactive_mode(self):
        """Run interactive simulation mode."""
        print("\nInteractive Mode")
        print("-"*80)
        print("Commands:")
        print("  m - Mint NFT")
        print("  c - WiFi Connect")
        print("  d - WiFi Disconnect")
        print("  s - Network Scan")
        print("  p - Peer Join")
        print("  r - Random Event")
        print("  v - Visualize Tesseract")
        print("  t - Show Statistics")
        print("  q - Quit")
        print("-"*80 + "\n")
        
        while True:
            try:
                cmd = input("Command: ").strip().lower()
                
                if cmd == 'q':
                    print("Exiting...")
                    break
                elif cmd == 'm':
                    self.simulate_step("mint_nft")
                elif cmd == 'c':
                    self.simulate_step("wifi_connect")
                elif cmd == 'd':
                    self.simulate_step("wifi_disconnect")
                elif cmd == 's':
                    self.simulate_step("network_scan")
                elif cmd == 'p':
                    self.simulate_step("peer_join")
                elif cmd == 'r':
                    self.simulate_step("random")
                elif cmd == 'v':
                    self.visualize_tesseract()
                elif cmd == 't':
                    self.show_statistics()
                else:
                    print("Unknown command")
            
            except KeyboardInterrupt:
                print("\n\nExiting...")
                break
            except EOFError:
                print("\n\nExiting...")
                break
    
    def show_statistics(self):
        """Show simulation statistics."""
        print("\n" + "="*80)
        print("SIMULATION STATISTICS")
        print("="*80)
        
        all_nfts = self.client.list_all_nfts()
        stats = self.client.get_tesseract_stats()
        
        print(f"\nSteps Executed: {self.step_count}")
        print(f"Total NFTs: {stats['total_nfts']}")
        print(f"Occupied Vertices: {stats['occupied_vertices']}/{stats['max_vertices']}")
        
        # Event breakdown
        event_counts = {}
        for event in self.events:
            event_type = event.get('event', 'unknown')
            event_counts[event_type] = event_counts.get(event_type, 0) + 1
        
        if event_counts:
            print("\nEvent Breakdown:")
            for event_type, count in sorted(event_counts.items()):
                print(f"  {event_type:20s}: {count}")
        
        # NFT distribution
        if all_nfts:
            print("\nNFT Distribution:")
            for vertex_str, count in stats['distribution'].items():
                print(f"  {vertex_str:15s}: {count} NFT(s)")
        
        # Transfer statistics
        total_transfers = sum(len(nft['transfer_history']) for nft in all_nfts)
        if total_transfers > 0:
            print(f"\nTotal Transfers: {total_transfers}")
            avg_transfers = total_transfers / len(all_nfts)
            print(f"Average Transfers per NFT: {avg_transfers:.2f}")
        
        print("="*80 + "\n")
    
    def demo_mode(self):
        """Run a pre-scripted demo."""
        print("\nDemo Mode - Blockcode NFT System")
        print("="*80)
        print("This demo will:")
        print("  1. Mint 3 NFTs at different vertices")
        print("  2. Simulate WiFi connect (temporal evolution)")
        print("  3. Simulate network scan (spatial movement)")
        print("  4. Simulate peer join (spatial movement)")
        print("  5. Show final state")
        print("="*80 + "\n")
        
        input("Press Enter to start...")
        
        # Step 1: Mint NFTs
        print("\n" + "─"*80)
        print("Phase 1: Minting NFTs")
        print("─"*80)
        
        for i in range(3):
            self.simulate_step("mint_nft")
            time.sleep(0.5)
        
        self.visualize_tesseract()
        input("\nPress Enter to continue...")
        
        # Step 2: WiFi connect
        print("\n" + "─"*80)
        print("Phase 2: WiFi Connection Event")
        print("─"*80)
        
        self.simulate_step("wifi_connect")
        self.visualize_tesseract()
        input("\nPress Enter to continue...")
        
        # Step 3: Network scan
        print("\n" + "─"*80)
        print("Phase 3: Network Scan")
        print("─"*80)
        
        self.simulate_step("network_scan")
        self.visualize_tesseract()
        input("\nPress Enter to continue...")
        
        # Step 4: Peer join
        print("\n" + "─"*80)
        print("Phase 4: Peer Joins Network")
        print("─"*80)
        
        self.simulate_step("peer_join")
        self.visualize_tesseract()
        
        # Final stats
        print("\n" + "─"*80)
        print("Demo Complete!")
        print("─"*80)
        self.show_statistics()


def main():
    """Main entry point for simulator."""
    import sys
    
    simulator = BlockcodeSimulator()
    
    # Check command line args
    if len(sys.argv) > 1:
        mode = sys.argv[1]
        
        if mode == "--demo":
            simulator.demo_mode()
        elif mode == "--auto":
            steps = int(sys.argv[2]) if len(sys.argv) > 2 else 10
            delay = float(sys.argv[3]) if len(sys.argv) > 3 else 1.0
            simulator.run_simulation(steps, delay)
        elif mode == "--interactive":
            simulator.interactive_mode()
        else:
            print(f"Unknown mode: {mode}")
            print("Usage: python blockcode_simulator.py [--demo|--auto|--interactive]")
    else:
        # Default: interactive mode
        simulator.interactive_mode()


if __name__ == "__main__":
    main()