class iR3Reputation:
    """
    Reputation app using pure flux architecture
    Built on top of iR³ foundation from post 878
    
    Total code: ~300 lines
    Foundation code: ~1700 lines (iR³Series, iR³DHT, iR³BitTorrent)
    """
    def __init__(self, node_id):
        self.node_id = node_id
        
        # Use iR³Series for events
        from ir3_series import iR3Series
        self.reputation_series = iR3Series(f'reputation_{node_id}')
        
        # Use iR³DHT for broadcast
        from ir3_dht import iR3DHT
        self.dht = iR3DHT()
        
        # Use iR³BitTorrent for chunks
        from ir3_bittorrent import iR3BitTorrent
        self.bt = iR3BitTorrent()
        
        # Rate limiters (from post 878)
        self.rate_limiters = {
            'w_tracking': 1.0,  # Tracking bandwidth
            'w_objective': 1.0, # Value ratio
            'w_topology': 1.0   # Network load
        }

def record_reputation_event(self, event_type, **details):
    """
    Record reputation event
    Pure flux: append → push → done
    No blocking, no waiting
    """
    # 1. Append to series (push-only)
    self.reputation_series.append({
        'timestamp': time.time(),
        'event_type': event_type,
        'node_id': self.node_id,
        **details
    })
    
    # 2. Push recent chunks to BitTorrent (async)
    if len(self.reputation_series) % 10 == 0:
        self._push_reputation_chunks()
    
    # Done! No waiting, no blocking
    # Events flow through pure flux channels

# Good action
reputation.record_reputation_event(
    'ecosystem_improved',
    territory='forest_A',
    health_delta=+15,
    timestamp=time.time()
)

# Bad action
reputation.record_reputation_event(
    'ecosystem_degraded',
    territory='forest_B',
    health_delta=-10,
    timestamp=time.time()
)

# Dispute resolved
reputation.record_reputation_event(
    'dispute_resolved',
    dispute_id='dispute_123',
    outcome='consensus_reached',
    timestamp=time.time()
)

def _push_reputation_chunks(self):
    """
    Push reputation chunks to network
    Pure flux: broadcast intent → nodes respond async
    """
    # Get recent events
    recent = self.reputation_series.tail(10)
    
    # Create chunk
    chunk = {
        'chunk_id': f'rep_{self.node_id}_{len(self.reputation_series)}',
        'node_id': self.node_id,
        'events': recent,
        'timestamp': time.time()
    }
    
    # Broadcast intent to DHT (1-to-many)
    self.dht.broadcast({
        'type': 'store_reputation_chunk',
        'chunk_id': chunk['chunk_id'],
        'from': self.node_id
    })
    
    # BitTorrent nodes decide via rate limiters
    # They'll respond via P2P (1-to-1) if they want to store
    # NO WAITING HERE! Pure push.

def query_reputation(self, target_node_id):
    """
    Query another node's reputation
    Pure flux: broadcast query → collect responses async
    """
    # 1. Broadcast query to DHT (1-to-many)
    query_id = f'query_{self.node_id}_{time.time()}'
    
    self.dht.broadcast({
        'type': 'reputation_query',
        'query_id': query_id,
        'target_node': target_node_id,
        'from': self.node_id
    })
    
    # 2. Append query to series (for audit trail)
    self.reputation_series.append({
        'timestamp': time.time(),
        'event_type': 'reputation_query_sent',
        'target_node': target_node_id,
        'query_id': query_id
    })
    
    # 3. Set up response collector (async)
    # Responses come back via P2P (1-to-1)
    # This is non-blocking!
    return query_id  # Caller polls for responses

def collect_reputation_responses(self, query_id, timeout=5.0):
    """
    Collect responses for reputation query
    Non-blocking: check series for responses
    """
    start = time.time()
    responses = []
    
    while time.time() - start < timeout:
        # Check series for new responses
        recent = self.reputation_series.tail(100)
        
        for entry in recent:
            if (entry.get('event_type') == 'reputation_response_received' and
                entry.get('query_id') == query_id):
                responses.append(entry)
        
        # Found enough? Return early
        if len(responses) >= 3:
            break
        
        # Yield to other tasks (pure flux!)
        time.sleep(0.1)
    
    return responses

class BitTorrentReputationNode:
    """
    BT node stores reputation chunks
    Uses rate limiters from post 878
    """
    def __init__(self):
        self.stored_chunks = {}
        self.rate_limiters = {
            'w_tracking': 1.0,
            'w_objective': 1.0,
            'w_topology': 1.0
        }
    
    def handle_reputation_query(self, query):
        """
        Respond to reputation query
        Rate limiters decide if we respond
        """
        target = query['target_node']
        from_node = query['from']
        
        # Do we have chunks for target?
        my_chunks = [c for c in self.stored_chunks.values()
                     if c['node_id'] == target]
        
        if not my_chunks:
            # SILENCE (don't have data)
            return None
        
        # Check rate limiters
        if self.rate_limiters['w_tracking'] < 0.3:
            # NO (rate limited)
            self._send_p2p_response(from_node, {
                'type': 'reputation_response',
                'query_id': query['query_id'],
                'response': 'NO',
                'reason': 'rate_limited',
                'chunks_available': len(my_chunks)
            })
            return
        
        # YES (send chunks via P2P)
        self._send_p2p_response(from_node, {
            'type': 'reputation_response',
            'query_id': query['query_id'],
            'response': 'YES',
            'chunks': my_chunks,
            'total_events': sum(len(c['events']) for c in my_chunks)
        })
    
    def _send_p2p_response(self, to_node, response):
        """
        Send response via P2P (1-to-1)
        Pure flux: push only, no blocking
        """
        # Send directly to node (not via DHT)
        p2p_send(to_node, response)
        
        # Append to our series (audit trail)
        self.series.append({
            'timestamp': time.time(),
            'event_type': 'reputation_response_sent',
            'to_node': to_node,
            'response_type': response['response']
        })

def update_rate_limiters(self):
    """Update rate limiters based on system state"""
    
    # Tracking: How much bandwidth do I have?
    bandwidth_used = self.get_bandwidth_used()
    self.rate_limiters['w_tracking'] = 1.0 - (bandwidth_used / MAX_BANDWIDTH)
    
    # Objective: Is responding valuable?
    query_value = self.estimate_query_value()
    self.rate_limiters['w_objective'] = query_value
    
    # Topology: Is network overloaded?
    network_load = self.get_network_load()
    self.rate_limiters['w_topology'] = 1.0 - (network_load / MAX_LOAD)
    
    # Overall: Multiply limiters
    self.overall_limiter = (self.rate_limiters['w_tracking'] *
                           self.rate_limiters['w_objective'] *
                           self.rate_limiters['w_topology'])

def derive_reputation(self, query_id):
    """
    Derive reputation from collected responses
    Multi-perspective view
    """
    # Collect all responses
    responses = self.collect_reputation_responses(query_id)
    
    # Separate by type
    yes_responses = [r for r in responses if r['response'] == 'YES']
    no_responses = [r for r in responses if r['response'] == 'NO']
    # SILENCE = no response in series
    
    # Aggregate all chunks
    all_events = []
    for response in yes_responses:
        for chunk in response['chunks']:
            all_events.extend(chunk['events'])
    
    # Count positive vs negative
    positive = sum(1 for e in all_events 
                  if e['event_type'] in [
                      'ecosystem_improved',
                      'dispute_resolved',
                      'consensus_matched'
                  ])
    
    negative = sum(1 for e in all_events
                  if e['event_type'] in [
                      'ecosystem_degraded',
                      'dispute_failed',
                      'consensus_missed'
                  ])
    
    total = positive + negative
    if total == 0:
        return {
            'reputation': 0.5,  # Neutral
            'confidence': 'low',
            'sources': 0
        }
    
    return {
        'reputation': positive / total,
        'confidence': 'high' if len(yes_responses) >= 2 else 'medium',
        'sources': len(yes_responses),
        'total_events': total,
        'positive': positive,
        'negative': negative,
        'rate_limited': len(no_responses)
    }

{
    'reputation': 0.85,  # 85% positive
    'confidence': 'high',  # 3 sources
    'sources': 3,  # 3 BT nodes responded
    'total_events': 127,
    'positive': 108,
    'negative': 19,
    'rate_limited': 1  # 1 node had data but rate limited
}

# Alice does good work
alice = iR3Reputation('alice')
alice.record_reputation_event(
    'ecosystem_improved',
    territory='forest_A',
    health_delta=+20
)
# → Appends to series (push)
# → Pushes chunks to BT network (async)
# → Done! No blocking

# BT nodes receive chunk push
# → Check rate limiters
# → HIGH limiters: Store chunk, respond YES
# → LOW limiters: Respond NO
# → Offline: SILENCE

# Bob queries Alice's reputation
bob = iR3Reputation('bob')
query_id = bob.query_reputation('alice')
# → Broadcasts to DHT (1-to-many)
# → Appends query to series
# → Returns query_id immediately (non-blocking!)

# BT nodes receive query (via DHT)
# → Each checks if has Alice's chunks
# → Each checks rate limiters
# → Responds via P2P (1-to-1) to Bob

# Bob collects responses (async)
time.sleep(2.0)  # Give time for responses
reputation_data = bob.derive_reputation(query_id)
# → Reads responses from series
# → Aggregates chunks
# → Derives multi-perspective reputation

print(f"Alice reputation: {reputation_data['reputation']}")
# → 0.85 (from 3 sources, 127 events)

# Foundation (from post 878): ~1700 lines
iR3Series        # ~500 lines
iR3DHT           # ~600 lines  
iR3BitTorrent    # ~600 lines

# Reputation app: ~300 lines
class iR3Reputation:
    __init__                        # 15 lines
    record_reputation_event         # 12 lines
    _push_reputation_chunks         # 25 lines
    query_reputation                # 20 lines
    collect_reputation_responses    # 30 lines
    derive_reputation               # 40 lines
    
class BitTorrentReputationNode:
    __init__                        # 10 lines
    handle_reputation_query         # 35 lines
    _send_p2p_response             # 15 lines
    update_rate_limiters           # 30 lines
    handle_storage_request         # 40 lines
    
# Helper functions                 # 28 lines

Total: ~300 lines for complete reputation system!

benefits = {
    # From pure flux
    'no_blocking': 'All operations async',
    'push_only': 'No request/response complexity',
    'natural_backpressure': 'Rate limiters prevent overload',
    'simple_code': '~300 lines total',
    
    # From DHT broadcast
    'efficient_queries': '1-to-many broadcast',
    'no_centralization': 'Distributed DHT',
    'censorship_resistant': 'No single point of control',
    
    # From P2P responses
    'direct_communication': 'Node-to-node',
    'bandwidth_efficient': 'Only interested parties respond',
    'privacy': 'Responses not broadcast',
    
    # From series
    'audit_trail': 'Complete history',
    'verifiable': 'All events recorded',
    'append_only': 'No mutation',
    
    # From rate limiters
    'natural_limits': 'No arbitrary throttling',
    'adaptive': 'Responds to load',
    'fair': 'Based on actual capacity',
    
    # Overall
    'scalable': 'No central bottleneck',
    'reliable': 'Distributed storage',
    'fast': 'No waiting',
    'simple': 'Easy to understand'
}

def calculate_selection_weight(self, node_id, stake_eth):
    """
    Calculate selection weight
    Reputation dominates, stake amplifies
    """
    # Query reputation via pure flux
    query_id = self.query_reputation(node_id)
    time.sleep(2.0)  # Collect responses
    rep_data = self.derive_reputation(query_id)
    
    base_reputation = rep_data['reputation']
    
    # Stake amplifies (logarithmic)
    if stake_eth > 0:
        stake_multiplier = 1 + 0.1 * math.log(stake_eth)
    else:
        stake_multiplier = 1.0
    
    weight = base_reputation * stake_multiplier
    
    return {
        'weight': weight,
        'reputation': base_reputation,
        'stake': stake_eth,
        'multiplier': stake_multiplier,
        'confidence': rep_data['confidence']
    }

def handle_poor_performance(self, node_id):
    """
    Natural consequences via reputation system
    No punishment, no slashing
    """
    # Bad action recorded
    self.record_reputation_event(
        'ecosystem_degraded',
        node_id=node_id,
        details='...'
    )
    
    # Pushed to network (pure flux)
    # → Chunks updated in BT
    # → Future queries reflect this
    
    # Natural consequence:
    # → Lower reputation in next query
    # → Less likely selected
    # → Economic incentive to improve
    
    # NO slashing needed!
    # NO arbitrary punishment!
    # Market naturally responds to track record

# Traditional (request/response)
❌ def get_reputation(node_id):
    response = request_reputation(node_id)  # BLOCKS
    wait_for_response(response)             # BLOCKS
    return parse_response(response)
    # Total: Complex, blocking, centralized

# Pure flux (iR³ Reputation)
✅ def query_reputation(node_id):
    query_id = dht.broadcast({...})        # NON-BLOCKING
    return query_id                         # IMMEDIATE
    
def collect_responses(query_id):
    responses = series.tail(100)            # READ SERIES
    return filter_by_query_id(responses)
    # Total: Simple, async, distributed

def assess_confidence(self, reputation_data):
    """
    Confidence based on number of sources
    """
    sources = reputation_data['sources']
    total_events = reputation_data['total_events']
    
    if sources == 0:
        return 'none'
    elif sources == 1:
        return 'low'
    elif sources == 2:
        return 'medium'
    elif sources >= 3 and total_events >= 50:
        return 'high'
    elif sources >= 5 and total_events >= 100:
        return 'very_high'
    else:
        return 'medium'

# Single source
{
    'reputation': 0.9,
    'sources': 1,
    'total_events': 20,
    'confidence': 'low'  # Only 1 BT node
}

# Multiple sources
{
    'reputation': 0.85,
    'sources': 4,
    'total_events': 150,
    'confidence': 'high'  # 4 BT nodes, 150 events
}

# Scenario 1: High capacity BT node
bt_node_1 = {
    'w_tracking': 0.9,    # 90% bandwidth available
    'w_objective': 0.8,   # Query is valuable
    'w_topology': 0.7,    # Network not overloaded
    'overall': 0.504      # 50.4% > threshold
}
→ Response: YES (stores chunk, sends data)

# Scenario 2: Overloaded BT node
bt_node_2 = {
    'w_tracking': 0.2,    # 20% bandwidth (low!)
    'w_objective': 0.6,   # Query somewhat valuable
    'w_topology': 0.4,    # Network busy
    'overall': 0.048      # 4.8% < threshold
}
→ Response: NO (has data but rate limited)

# Scenario 3: No data BT node
bt_node_3 = {
    'has_chunks': False   # Doesn't have this node's data
}
→ Response: SILENCE (doesn't respond)

timeline = {
    'week_1': {
        'events': 5,
        'reputation': 0.5,    # Neutral (new)
        'confidence': 'low'
    },
    
    'month_1': {
        'events': 30,
        'reputation': 0.65,   # Building
        'confidence': 'medium'
    },
    
    'month_3': {
        'events': 100,
        'reputation': 0.75,   # Good
        'confidence': 'high'
    },
    
    'month_6': {
        'events': 250,
        'reputation': 0.82,   # Very good
        'confidence': 'high'
    },
    
    'year_1': {
        'events': 600,
        'reputation': 0.88,   # Excellent
        'confidence': 'very_high'
    }
}