import math

class DissolutionEngine:
    """
    Protocol 12: Hex/Binary Dissolution.
    Converts solid data objects into liquid Nibble Streams.
    """
    
    @staticmethod
    def dissolve(payload, encoding='utf-8'):
        """
        Generator that yields DissolvedPackets (Nibbles).
        payload: str or bytes
        """
        if isinstance(payload, str):
            payload = payload.encode(encoding)
            
        hex_str = payload.hex()
        
        # Stream Generation (Original Nibble Stream)
        for index, char in enumerate(hex_str):
            nibble_val = int(char, 16)
            weight = bin(nibble_val).count('1')
            
            # Entropy Routing Logic (Bitwise Gravity)
            if weight >= 3:
                routing_tag = "FAST_LANE_MERSENNE" 
            elif weight == 0:
                routing_tag = "CONTROL_SIGNAL"
            elif nibble_val % 2 == 0:
                routing_tag = "STANDARD_EVEN"
            else:
                routing_tag = "STANDARD_ODD"
                
            yield {
                'seq': index,
                'nibble': char,       
                'value': nibble_val,
                'entropy': weight,    
                'tag': routing_tag
            } 
            
    @staticmethod
    def dissolve_bytes(payload_bytes):
        """
        SPCW Deinterleave: Splits 8-bit Byte into Context | Bucket | Slot.
        """
        for i, byte in enumerate(payload_bytes):
            # 8 bits: [7 6 5 4] [3 2] [1 0]
            # Context (4b): High Nibble
            context = (byte >> 4) & 0xF
            
            # Bucket (2b): Persistence
            bucket = (byte >> 2) & 0x3
            
            # Slot (2b): Cycle
            slot = byte & 0x3
            
            # Entropy Calculation (on the full byte)
            weight = bin(byte).count('1')
            
            yield {
                'seq': i,
                'byte_val': byte,
                'context': context, # 0-15
                'bucket': bucket,   # 0-3
                'slot': slot,       # 0-3
                'entropy': weight,   # 0-8
                'tag': "SPCW_WAVE" 
            }

class RoutingMetric:
    """
    Calculates Transport Resistance based on Number Theory.
    """
    
    @staticmethod
    def calculate_resistance(node_a, node_b):
        """
        Metric = LCM(A,B) / GCD(A,B)^2
        Favors paths through shared factors.
        """
        if node_a == 0 or node_b == 0: return float('inf')
        
        gcd_val = math.gcd(node_a, node_b)
        lcm_val = abs(node_a * node_b) // gcd_val
        
        # The Metric Formula
        # Higher GCD = Lower Resistance (Better Path)
        try:
            metric = lcm_val / (gcd_val ** 2)
        except ZeroDivisionError:
            return float('inf')
            
        return round(metric, 4)

if __name__ == "__main__":
    # Test Dissolution
    payload = "Hello World"
    print(f"Dissolving: '{payload}'")
    stream = DissolutionEngine.dissolve(payload)
    for packet in stream:
        print(packet)
        
    # Test Metric
    r1 = RoutingMetric.calculate_resistance(6, 12) # Shared Factor 6 -> Should be low
    r2 = RoutingMetric.calculate_resistance(6, 7)  # Coprime -> Should be high
    print(f"Resistance(6 -> 12): {r1}")
    print(f"Resistance(6 -> 7): {r2}")