class SuprnovaDHT:
    """
    Distributed hash table infrastructure
    
    Provides core P2P primitives
    """
    
    def discover_peers(self, query: Query) -> List[Peer]:
        """
        Kademlia routing: O(log N) peer discovery
        
        Agents use this to find nearby agents
        """
        return self.routing_table.find_closest(query.key)
    
    def store_state(self, key: bytes, value: Any) -> bool:
        """
        Distributed state storage
        
        Mesh uses this to store substrate state
        """
        nodes = self.discover_peers(key)
        for node in nodes[:3]:  # Replicate to 3 nodes
            node.store(key, value)
        return True
    
    def gossip_message(self, message: Dict) -> None:
        """
        Epidemic broadcast
        
        Agents use this for peer-to-peer communication
        """
        peers = self.get_random_peers(fanout=3)
        for peer in peers:
            peer.forward_message(message)
            # Peers forward to their peers (epidemic spread)
    
    def query_local(self, position: Any, radius: float) -> List[Agent]:
        """
        Spatial query using DHT
        
        Returns agents within radius of position
        Uses consistent hashing for spatial indexing
        """
        spatial_key = self.hash_position(position)
        nearby_keys = self.routing_table.get_range(
            spatial_key,
            radius
        )
        
        agents = []
        for key in nearby_keys:
            agent_data = self.retrieve_state(key)
            agents.append(agent_data)
        
        return agents

class UniversalMesh:
    """
    Substrate layer - runs ON Suprnova-DHT
    
    Provides state evolution space for agents
    """
    
    def __init__(
        self,
        S_0: Any,              # Initial state
        F: Callable,           # Evolution function
        E_p: List[Callable],   # Entropy sources
        dht: SuprnovaDHT       # DHT infrastructure
    ):
        self.state = S_0
        self.evolution = F
        self.entropy_sources = E_p
        self.dht = dht  # Uses DHT for storage/discovery
        self.mesh_id = self.dht.register_mesh(self)
    
    def query_local_agents(
        self,
        position: Any,
        radius: float
    ) -> Set[Agent]:
        """
        Query for nearby agents using DHT
        
        DHT provides spatial indexing and discovery
        """
        return self.dht.query_local(position, radius)
    
    def step(self):
        """
        Evolve mesh state: S(n+1) = F(S(n)) ⊕ E_p(S(n))
        
        State stored in DHT (distributed)
        """
        # Compute next state
        next_state = self.evolution(self.state)
        
        for e_p in self.entropy_sources:
            entropy = e_p(self.state)
            next_state = self._compose(next_state, entropy)
        
        # Store in DHT (replicated across nodes)
        self.dht.store_state(
            key=f"mesh_{self.mesh_id}_state",
            value=next_state
        )
        
        self.state = next_state
        self.iteration += 1
    
    def get_state(self) -> Any:
        """
        Retrieve mesh state from DHT
        
        Can be called from any DHT node
        """
        return self.dht.retrieve_state(
            key=f"mesh_{self.mesh_id}_state"
        )

class Agent:
    """
    Autonomous agent - runs ON UniversalMesh substrate
    
    Uses DHT for peer discovery, uses Mesh for state space
    """
    
    def __init__(
        self,
        agent_id: str,
        position: Any,
        requirements: Dict,
        mesh: UniversalMesh  # Reference to mesh (and its DHT)
    ):
        self.id = agent_id
        self.position = position
        self.requirements = requirements
        self.mesh = mesh
        self.dht = mesh.dht  # Access to DHT through mesh
        self.peers: Set[Agent] = set()
        
        # Register with DHT (for discoverability)
        self.dht.store_state(
            key=self._spatial_key(),
            value={'agent_id': self.id, 'position': self.position}
        )
    
    def _spatial_key(self) -> bytes:
        """Hash position for DHT spatial indexing"""
        return self.dht.hash_position(self.position)
    
    def discover_peers(self) -> Set[Agent]:
        """
        Discover nearby agents via DHT
        
        O(log N) lookup using Kademlia routing
        """
        # Query DHT for agents near our position
        nearby = self.dht.query_local(
            position=self.position,
            radius=self.requirements.get('interaction_range', 10)
        )
        
        self.peers.update(nearby)
        return nearby
    
    def send_to_peer(self, peer: Agent, message: Dict):
        """
        Send message to peer via DHT gossip
        
        No central message broker
        """
        self.dht.gossip_message({
            'from': self.id,
            'to': peer.id,
            'payload': message
        })
    
    def step(self):
        """
        Autonomous agent loop
        
        All operations distributed via DHT
        """
        # 1. Discover peers (DHT query)
        self.discover_peers()
        
        # 2. Check conflicts (peer-to-peer)
        conflicts = self.check_conflicts_with_peers()
        
        # 3. Negotiate resolutions (DHT gossip)
        for conflict in conflicts:
            resolution = self.negotiate_resolution(conflict)
            if resolution:
                self.apply_resolution(resolution)
        
        # 4. Update position in DHT
        self.dht.store_state(
            key=self._spatial_key(),
            value={'agent_id': self.id, 'position': self.position}
        )
    
    def run_autonomous(self):
        """Run agent independently"""
        while True:
            self.step()
            time.sleep(0.01)

# ===== LAYER 1: DHT =====
dht = SuprnovaDHT(
    biometric_id=fingerprint_hash(),
    egi_coordinator="https://current-reality.eth"
)

# ===== LAYER 2: MESH =====
chess_mesh = UniversalMesh(
    S_0=BoardState(pieces=initial_position),
    F=chess_rules,  # Board physics
    E_p=[
        lambda s: mover_white_suggestions(s),
        lambda s: mover_black_suggestions(s)
    ],
    dht=dht  # Mesh runs on DHT
)

# ===== LAYER 3: AGENTS =====
pieces = []
for square in chess.SQUARES:
    piece_data = chess_mesh.state.pieces[square]
    if piece_data:
        agent = ChessPiece(
            piece_id=f"{piece_data.color}_{piece_data.type}_{square}",
            position=square,
            requirements={'mobility': piece_data.legal_moves},
            mesh=chess_mesh  # Agent lives on mesh
        )
        pieces.append(agent)

# ===== RUN STACK =====

# Start DHT (in background)
dht.start()

# Start mesh evolution (using DHT for storage)
threading.Thread(target=chess_mesh.run).start()

# Start each piece autonomously
for piece in pieces:
    threading.Thread(target=piece.run_autonomous).start()

# ===== WHAT HAPPENS =====

# 1. DHT provides peer discovery:
#    - White knight queries DHT for nearby pieces
#    - DHT returns: "White bishop at f3, Black pawn at e5"
#    - O(log N) lookup using Kademlia

# 2. Mesh provides state space:
#    - Board state stored in DHT (replicated)
#    - Evolution function applies chess rules
#    - Configuration space = legal positions

# 3. Agents coordinate:
#    - Knight discovers bishop (DHT)
#    - Knight negotiates move (gossip)
#    - Bishop responds (peer-to-peer)
#    - Emergent strategy (no central coach)

# All distributed. No central point.

class MeshDHTAdapter:
    """
    Adapter between UniversalMesh and Suprnova-DHT
    
    Handles serialization, spatial indexing, etc.
    """
    
    def __init__(self, dht: SuprnovaDHT):
        self.dht = dht
        self.spatial_index = SpatialHashIndex(dht)
    
    def store_mesh_state(self, mesh_id: str, state: Any):
        """Store mesh state in DHT"""
        # Serialize state
        serialized = self._serialize(state)
        
        # Store with replication
        key = f"mesh_{mesh_id}_state_{hash(serialized)}"
        self.dht.store_state(key, serialized)
    
    def query_agents_spatial(
        self,
        position: Vector,
        radius: float
    ) -> List[AgentData]:
        """Spatial query using DHT consistent hashing"""
        return self.spatial_index.query_range(position, radius)

class AgentDiscoveryProtocol:
    """
    DHT-based agent discovery
    
    Uses Kademlia + spatial hashing
    """
    
    def announce_presence(self, agent: Agent):
        """Announce agent to DHT network"""
        self.dht.store_state(
            key=self._spatial_hash(agent.position),
            value={
                'agent_id': agent.id,
                'position': agent.position,
                'timestamp': time.time(),
                'capabilities': agent.capabilities
            }
        )
    
    def find_nearby(
        self,
        position: Vector,
        radius: float,
        filter_fn: Optional[Callable] = None
    ) -> List[Agent]:
        """Find agents near position"""
        # Query DHT for agents in spatial range
        candidates = self.dht.query_local(position, radius)
        
        # Apply filter if provided
        if filter_fn:
            candidates = [a for a in candidates if filter_fn(a)]
        
        return candidates