blockcode_nft_client.py

"""Blockcode NFT Client - Tesseract-based NFT operations."""

import time
from typing import Optional, Dict, Any, List, Tuple
from datetime import datetime
import json


class BlockcodeNFTClient:
    """NFT client using blockcode addressing on tesseract geometry."""
    
    # Code set definitions
    SPATIAL_CODES = ["AB", "AABB", "ABAB", "ABBA"]
    RHYTHM_CODES = ["2:4", "3:3", "4:4", "5:3"]
    STRUCTURE_CODES = ["P&B", "P|B", "P→B", "P←B"]
    TRANSFORM_CODES = ["F1", "F2", "F3", "F4"]
    TEMPORAL_CODES = ["t_past", "t_now", "t_future", "t_loop"]
    
    def __init__(self, tesseract_id: str = "main", local_vertex: List[int] = None):
        """Initialize blockcode NFT client.
        
        Args:
            tesseract_id: Identifier for the tesseract network
            local_vertex: Local position on tesseract [x, y, z, t]
        """
        self.tesseract_id = tesseract_id
        self.local_vertex = local_vertex or [0, 0, 0, 0]
        
        # Validate vertex
        if not self._is_valid_vertex(self.local_vertex):
            raise ValueError(f"Invalid vertex: {self.local_vertex}")
        
        # In-memory NFT storage (would be database in production)
        self.nft_registry = {}
        
        print(f"✓ Blockcode NFT client initialized")
        print(f"✓ Tesseract: {tesseract_id}")
        print(f"✓ Local vertex: {self.local_vertex}")
    
    def _is_valid_vertex(self, vertex: List[int]) -> bool:
        """Check if vertex coordinates are valid (must be 0 or 1)."""
        if len(vertex) != 4:
            return False
        return all(v in [0, 1] for v in vertex)
    
    def _generate_pattern_code(self, 
                              spatial: str, 
                              rhythm: str, 
                              structure: str, 
                              transform: str) -> str:
        """Generate a blockcode pattern."""
        return f"{spatial}.{rhythm}.{structure}.{transform}"
    
    def _parse_pattern_code(self, pattern: str) -> Dict[str, str]:
        """Parse a blockcode pattern into components."""
        parts = pattern.split('.')
        if len(parts) != 4:
            raise ValueError(f"Invalid pattern code: {pattern}")
        
        return {
            "spatial": parts[0],
            "rhythm": parts[1],
            "structure": parts[2],
            "transform": parts[3]
        }
    
    def _calculate_hamming_distance(self, v1: List[int], v2: List[int]) -> int:
        """Calculate Hamming distance between two vertices."""
        return sum(a != b for a, b in zip(v1, v2))
    
    def _get_edge_type(self, from_vertex: List[int], to_vertex: List[int]) -> Optional[str]:
        """Determine edge type between two vertices."""
        diff = [to_vertex[i] - from_vertex[i] for i in range(4)]
        
        if diff == [1, 0, 0, 0] or diff == [-1, 0, 0, 0]:
            return "X-edge"
        elif diff == [0, 1, 0, 0] or diff == [0, -1, 0, 0]:
            return "Y-edge"
        elif diff == [0, 0, 1, 0] or diff == [0, 0, -1, 0]:
            return "Z-edge"
        elif diff == [0, 0, 0, 1] or diff == [0, 0, 0, -1]:
            return "T-edge"
        else:
            return None
    
    def calculate_path(self, 
                      from_vertex: List[int], 
                      to_vertex: List[int]) -> List[str]:
        """Calculate shortest path between two vertices on tesseract."""
        path = []
        current = from_vertex.copy()
        
        # Traverse each dimension
        for dim in range(4):
            if current[dim] != to_vertex[dim]:
                edge_types = ["X-edge", "Y-edge", "Z-edge", "T-edge"]
                path.append(edge_types[dim])
                current[dim] = to_vertex[dim]
        
        return path
    
    def _apply_edge_transformation(self, 
                                  data: Dict[str, Any], 
                                  edge_type: str) -> Dict[str, Any]:
        """Apply blockcode transformation based on edge type."""
        transformations = {
            "X-edge": "AB",      # Alternating pattern
            "Y-edge": "AABB",    # Grouped alternating
            "Z-edge": "P&B",     # Pitch and beat
            "T-edge": "Fold"     # Temporal compression
        }
        
        transformed = data.copy()
        transformed['_transformation'] = transformations.get(edge_type, "None")
        transformed['_edge_type'] = edge_type
        
        return transformed
    
    def quote(self, data: Dict[str, Any], transform_code: str) -> str:
        """Quote operation: freeze data into stable token."""
        data_str = json.dumps(data, sort_keys=True)
        quoted = f"QUOTE[{transform_code}]:{data_str}"
        return quoted
    
    def unquote(self, quoted_data: str) -> Dict[str, Any]:
        """Unquote operation: release token back into flow."""
        if not quoted_data.startswith("QUOTE["):
            raise ValueError("Invalid quoted data format")
        
        # Extract transform code and data
        parts = quoted_data.split("]:", 1)
        if len(parts) != 2:
            raise ValueError("Invalid quoted data structure")
        
        data_str = parts[1]
        return json.loads(data_str)
    
    def mint_nft(self,
                pattern_code: str,
                vertex: List[int],
                owner_pattern: str,
                metadata: Dict[str, Any]) -> Dict[str, Any]:
        """Mint a new NFT at a tesseract vertex.
        
        Args:
            pattern_code: Unique blockcode pattern (e.g., "AB.2:4.P&B.F1")
            vertex: Tesseract vertex [x, y, z, t]
            owner_pattern: Owner's blockcode pattern
            metadata: NFT metadata dictionary
            
        Returns:
            NFT record dictionary
        """
        # Validate inputs
        if not self._is_valid_vertex(vertex):
            raise ValueError(f"Invalid vertex: {vertex}")
        
        if pattern_code in self.nft_registry:
            raise ValueError(f"NFT with pattern {pattern_code} already exists")
        
        # Create NFT record
        nft = {
            "pattern_code": pattern_code,
            "vertex": vertex,
            "owner_pattern": owner_pattern,
            "metadata": metadata,
            "metadata_vector": metadata.get("audio_vector", [0, 0, 0, 0]),
            "created_at": datetime.now().isoformat(),
            "transfer_history": []
        }
        
        # Store in registry
        self.nft_registry[pattern_code] = nft
        
        print(f"✓ NFT minted: {pattern_code} at vertex {vertex}")
        return nft
    
    def transfer_nft(self,
                    pattern_code: str,
                    from_vertex: List[int],
                    to_vertex: List[int],
                    new_owner_pattern: str) -> Dict[str, Any]:
        """Transfer NFT to a new vertex and owner.
        
        Args:
            pattern_code: NFT pattern code
            from_vertex: Current vertex
            to_vertex: Target vertex
            new_owner_pattern: New owner's blockcode pattern
            
        Returns:
            Transfer record dictionary
        """
        # Get NFT
        if pattern_code not in self.nft_registry:
            raise ValueError(f"NFT not found: {pattern_code}")
        
        nft = self.nft_registry[pattern_code]
        
        # Verify current location
        if nft["vertex"] != from_vertex:
            raise ValueError(f"NFT not at specified vertex. Current: {nft['vertex']}, Specified: {from_vertex}")
        
        # Validate vertices
        if not self._is_valid_vertex(to_vertex):
            raise ValueError(f"Invalid target vertex: {to_vertex}")
        
        # Calculate path
        path = self.calculate_path(from_vertex, to_vertex)
        distance = self._calculate_hamming_distance(from_vertex, to_vertex)
        
        # Create transfer record
        transfer_record = {
            "from_vertex": from_vertex,
            "to_vertex": to_vertex,
            "from_owner": nft["owner_pattern"],
            "to_owner": new_owner_pattern,
            "path": path,
            "distance": distance,
            "timestamp": datetime.now().isoformat()
        }
        
        # Update NFT
        nft["vertex"] = to_vertex
        nft["owner_pattern"] = new_owner_pattern
        nft["transfer_history"].append(transfer_record)
        
        print(f"✓ NFT transferred: {pattern_code}")
        print(f"  Path: {' → '.join(path)}")
        print(f"  Distance: {distance} hops")
        
        return transfer_record
    
    def get_nft_by_pattern(self, pattern_code: str) -> Optional[Dict[str, Any]]:
        """Get NFT by pattern code."""
        return self.nft_registry.get(pattern_code)
    
    def get_nfts_at_vertex(self, vertex: List[int]) -> List[Dict[str, Any]]:
        """Get all NFTs at a specific vertex."""
        return [
            nft for nft in self.nft_registry.values()
            if nft["vertex"] == vertex
        ]
    
    def get_nfts_by_owner(self, owner_pattern: str) -> List[Dict[str, Any]]:
        """Get all NFTs owned by a specific pattern."""
        return [
            nft for nft in self.nft_registry.values()
            if nft["owner_pattern"] == owner_pattern
        ]
    
    def propagate_temporal(self,
                          pattern_code: str,
                          from_vertex: List[int],
                          to_vertex: List[int],
                          fold_operation: str = "F1") -> Dict[str, Any]:
        """Propagate NFT through temporal T-edge (viral RNA mutation).
        
        Args:
            pattern_code: NFT pattern code
            from_vertex: Current vertex (t=0)
            to_vertex: Target vertex (t=1)
            fold_operation: Fold transformation to apply
            
        Returns:
            Evolved NFT record
        """
        # Verify T-edge traversal
        edge_type = self._get_edge_type(from_vertex, to_vertex)
        if edge_type != "T-edge":
            raise ValueError(f"Not a T-edge traversal: {edge_type}")
        
        # Get original NFT
        original_nft = self.get_nft_by_pattern(pattern_code)
        if not original_nft:
            raise ValueError(f"NFT not found: {pattern_code}")
        
        # Create evolved pattern
        parsed = self._parse_pattern_code(pattern_code)
        evolved_pattern = f"{parsed['spatial']}.{parsed['rhythm']}.{parsed['structure']}.{fold_operation}"
        
        # Apply fold transformation
        evolved_metadata = original_nft["metadata"].copy()
        evolved_metadata['_evolved_from'] = pattern_code
        evolved_metadata['_fold_applied'] = fold_operation
        evolved_metadata['_evolution_time'] = datetime.now().isoformat()
        
        # Mint evolved NFT
        evolved_nft = self.mint_nft(
            pattern_code=evolved_pattern,
            vertex=to_vertex,
            owner_pattern=original_nft["owner_pattern"],
            metadata=evolved_metadata
        )
        
        print(f"✓ Temporal propagation: {pattern_code} → {evolved_pattern}")
        print(f"  Fold operation: {fold_operation}")
        
        return evolved_nft
    
    def list_all_nfts(self) -> List[Dict[str, Any]]:
        """List all NFTs in registry."""
        return list(self.nft_registry.values())
    
    def get_tesseract_stats(self) -> Dict[str, Any]:
        """Get statistics about NFT distribution on tesseract."""
        vertex_counts = {}
        
        for nft in self.nft_registry.values():
            vertex_key = tuple(nft["vertex"])
            vertex_counts[vertex_key] = vertex_counts.get(vertex_key, 0) + 1
        
        return {
            "total_nfts": len(self.nft_registry),
            "occupied_vertices": len(vertex_counts),
            "max_vertices": 16,  # Tesseract has 16 vertices
            "distribution": {str(k): v for k, v in vertex_counts.items()},
            "tesseract_id": self.tesseract_id
        }


def get_blockcode_nft_client(tesseract_id: str = "main", 
                             local_vertex: List[int] = None) -> BlockcodeNFTClient:
    """Get a blockcode NFT client instance.
    
    Args:
        tesseract_id: Tesseract network identifier
        local_vertex: Local position on tesseract
        
    Returns:
        Configured BlockcodeNFTClient instance
    """
    return BlockcodeNFTClient(tesseract_id, local_vertex)