# Local node
class Node:
    def __init__(self):
        # ONLY series
        self.series = [
            {'t': time.time(), 'event': 'initialized'}
        ]
    
    def declare_intent(self, want):
        """
        Declare intention (not request!)
        Broadcast via DHT
        """
        # Declare to DHT: "I want X"
        dht.broadcast_intent({
            'from': self.address,
            'intent': 'want_chunk',
            'chunk_id': want
        })
        
        # Append declaration to MY series
        self._append_series('declared_intent',
                          chunk_id=want,
                          broadcast_time=time.time())
        
        # Wait for responses (or silence)
        # Each response appended to series

❌ "Can you give me X?" (question)
❌ send_request(node, 'get', chunk_id)

✅ "I want X" (declaration)
✅ dht.broadcast_intent(...)

class IntentResponse:
    """All responses are valid data points"""
    
    def process_responses(self, intent_id):
        """Collect all responses to intent"""
        responses = {
            'yes': [],      # Nodes that provided
            'no': [],       # Nodes that refused
            'silence': []   # Nodes that ignored
        }
        
        # Scan series for responses
        for entry in self.series:
            if entry.get('intent_id') == intent_id:
                if entry['response'] == 'yes':
                    responses['yes'].append(entry)
                elif entry['response'] == 'no':
                    responses['no'].append(entry)
                elif entry['response'] == 'silence':
                    responses['silence'].append(entry)
        
        return responses
    
    def derive_insights(self, responses):
        """Each response type gives information"""
        
        # YES = I have it and can share
        availability = len(responses['yes'])
        
        # NO = I have it but won't share (rate limited)
        # → Tells you: resource exists, node loaded
        congestion = len(responses['no'])
        
        # SILENCE = Didn't respond
        # → Tells you: don't have it, offline, or ignored
        unknowns = len(responses['silence'])
        
        return {
            'available_from': availability,
            'congested_nodes': congestion,
            'unknown_state': unknowns,
            'total_queried': availability + congestion + unknowns
        }

class BitTorrentNode:
    """BT node with rate limiters"""
    
    def receive_intent(self, intent):
        """Intent broadcast received - decide response"""
        chunk_id = intent['chunk_id']
        
        # Do I have it?
        storage = self._derive_storage()
        if chunk_id not in storage:
            # Don't have it → SILENCE
            return None
        
        # Have it - check rate limiters
        limiters = self._compute_rate_limiters()
        
        if self._should_share(chunk_id, limiters):
            # YES - share it
            self._respond_yes(intent, storage[chunk_id])
        else:
            # NO - have it but rate limited
            self._respond_no(intent, reason='rate_limited')
    
    def _compute_rate_limiters(self):
        """Compute from series"""
        storage = self._derive_storage()
        
        # Economic: storage space
        total_size = sum(len(str(d)) for d in storage.values())
        storage_budget = 100 * 1024 * 1024  # 100MB
        economic = 1.0 - (total_size / storage_budget)
        
        # Objective: chunk popularity
        objective = 1.0 if len(storage) < 50 else 0.3
        
        # W tracking: recent requests
        recent_requests = sum(1 for e in self.series[-100:]
                             if e.get('event') == 'intent_received')
        w_tracking = 1.0 - (recent_requests / 100)
        
        # Topology: network health
        topology = 1.0  # Simplified
        
        return {
            'economic': economic,
            'objective': objective,
            'w_tracking': w_tracking,
            'topology': topology
        }
    
    def _should_share(self, chunk_id, limiters):
        """Decision logic"""
        # All limiters green → YES
        if all(v > 0.7 for v in limiters.values()):
            return True
        
        # Economic critical → NO
        if limiters['economic'] < 0.2:
            return False
        
        # High load → NO
        if limiters['w_tracking'] < 0.3:
            return False
        
        # Borderline → YES
        return True

class DHT:
    """Distributed Hash Table"""
    
    def broadcast_intent(self, intent):
        """Broadcast to all relevant nodes"""
        # Get all BT nodes
        bt_nodes = self._find_nodes(type='bt')
        
        # Broadcast to all
        for node in bt_nodes:
            try:
                self._send_intent(node, intent)
            except:
                # Node offline → will appear as SILENCE
                pass
        
        # Log broadcast
        self._append_series('intent_broadcast',
                          intent_id=intent['id'],
                          targets=len(bt_nodes))
    
    def _find_nodes(self, type):
        """Find nodes by type from series"""
        nodes = []
        for entry in self.series:
            if entry.get('event') == 'peer_added':
                if entry.get('peer_type') == type:
                    nodes.append(entry['peer'])
        return nodes

class SeriesChunking:
    """Split series into chunks for BT"""
    
    def chunk_series(self, series, chunk_size=10):
        """Split series into chunks"""
        chunks = []
        for i in range(0, len(series), chunk_size):
            chunk = {
                'chunk_id': f'series_{self.node_id}_{i}',
                'events': series[i:i+chunk_size],
                'start_time': series[i]['t'],
                'end_time': series[min(i+chunk_size-1, len(series)-1)]['t']
            }
            chunks.append(chunk)
        return chunks
    
    def push_chunks_to_bt(self, chunks):
        """Push chunks to BT network"""
        for chunk in chunks:
            # Declare intent to store
            dht.broadcast_intent({
                'from': self.address,
                'intent': 'store_chunk',
                'chunk_id': chunk['chunk_id'],
                'data': chunk
            })
            
            # BT nodes decide whether to accept
            # (Based on their rate limiters)

class MultiPerspective:
    """Derive from multiple perspectives"""
    
    def fetch_perspectives(self, event_type):
        """Fetch chunks from multiple nodes"""
        # Declare intent for relevant chunks
        dht.broadcast_intent({
            'intent': 'want_chunks',
            'filter': event_type,
            'from': self.address
        })
        
        # Collect responses
        perspectives = []
        for response in self._wait_for_responses():
            if response['result'] == 'yes':
                perspectives.append({
                    'node': response['from'],
                    'chunks': response['data']
                })
        
        return perspectives
    
    def derive_consensus(self, perspectives):
        """Derive truth from multiple series"""
        consensus = {}
        
        # Example: Mapping consensus
        observations = []
        for p in perspectives:
            for chunk in p['chunks']:
                for event in chunk['events']:
                    if event['event'] == 'observation':
                        observations.append({
                            'node': p['node'],
                            'value': event['observation'],
                            'reputation': self._get_reputation(p['node'])
                        })
        
        # Weighted consensus
        total_weight = sum(o['reputation'] for o in observations)
        consensus_value = sum(o['value'] * o['reputation'] 
                             for o in observations) / total_weight
        
        return consensus_value

# Node A wants to map territory
mapper_A = MapperNode('A')

# 1. Observe locally
mapper_A.observe_reality(location='forest_1')
# → Appends to local series

# 2. Want others' perspectives
mapper_A.declare_intent_to_dht({
    'intent': 'want_observations',
    'location': 'forest_1'
})

# 3. DHT broadcasts to all mapper nodes
# Mapper B: ✅ YES (sends observations)
# Mapper C: 🤷 SILENCE (offline)
# Mapper D: ✅ YES (sends observations)
# Mapper E: ❌ NO (has data but rate limited)

# 4. Mapper A receives responses
mapper_A._append_series('received_perspective',
                       from='B', data=observations_B)
mapper_A._append_series('silence',
                       from='C')
mapper_A._append_series('received_perspective',
                       from='D', data=observations_D)
mapper_A._append_series('rejected',
                       from='E', reason='rate_limited')

# 5. Derive consensus from available perspectives
consensus = mapper_A.derive_consensus([
    observations_A,  # Own
    observations_B,  # From B
    observations_D   # From D
])

# 6. Store consensus chunks to BT
mapper_A.push_chunks_to_bt(consensus_chunks)

# 7. Announce to DHT
dht.announce('chunk:consensus_forest_1', mapper_A.address)

# Point-to-point request
response = node_B.get(chunk_id)

# Problems:
- Single point of failure
- No alternatives if rejected
- Silence = error (not data)
- No multi-perspective

# Broadcast intention
dht.broadcast_intent('want_chunk', chunk_id)

# Benefits:
✓ Multiple responders
✓ Alternatives if some reject
✓ Silence is information
✓ Multi-perspective by default
✓ Rate limiting natural
✓ Autonomous decisions

self.series = [...]  # Append-only
state = _derive_from_series()

dht.broadcast_intent("I want X")
# NOT: request("give me X")

responses = {
    'yes': [nodes that shared],
    'no': [nodes that refused],
    'silence': [nodes that ignored]
}
# ALL are valid data points