import hashlib
import json
from datetime import datetime, timedelta
from typing import List, Dict, Generator, Tuple
import itertools

class CrownHoldingsBondFactory:
    def __init__(self):
        self.namespaces = ["ALPHA", "BETA", "GAMMA", "DELTA", "EPSILON", "ZETA", "OMEGA"]
        self.patterns = ["SIMPLE", "COMPOUND", "ZERO", "INFLATION", "CALLABLE", "CONVERTIBLE", "PERPETUAL", "RECURSIVE"]
        self.extensions = ["1Y", "5Y", "10Y", "25Y", "50Y", "100Y", "2140"]
        
        # Crown Holdings Structure
        self.crown_entities = {
            "CROWN_IMPERIAL": {"tier": "ROYAL", "sovereign_backing": True, "reserve_ratio": 1.0},
            "CROWN_SOVEREIGN": {"tier": "IMPERIAL", "sovereign_backing": True, "reserve_ratio": 0.9},
            "CROWN_ROYAL": {"tier": "SOVEREIGN", "sovereign_backing": True, "reserve_ratio": 0.85},
            "CROWN_IMPERIUM": {"tier": "ROYAL", "sovereign_backing": False, "reserve_ratio": 0.8},
            "CROWN_DOMINION": {"tier": "IMPERIAL", "sovereign_backing": False, "reserve_ratio": 0.75},
            "CROWN_REALM": {"tier": "SOVEREIGN", "sovereign_backing": False, "reserve_ratio": 0.7},
            "CROWN_TRUST": {"tier": "NOBLE", "sovereign_backing": False, "reserve_ratio": 0.65}
        }
        
        self.theoretical_depth = len(self.namespaces) * len(self.patterns) * len(self.extensions) * len(self.crown_entities)
    
    def get_crown_entity(self, version: int) -> Tuple[str, Dict]:
        """Assign crown entity based on version with weighted distribution"""
        entities = list(self.crown_entities.keys())
        entity_index = version % len(entities)
        
        # Higher versions get better crown entities
        if version >= 5000000:
            entity_index = version % 3  # Top 3 entities
        elif version >= 1000000:
            entity_index = version % 5  # Top 5 entities
            
        entity_name = entities[entity_index]
        return entity_name, self.crown_entities[entity_name]
    
    def calculate_crown_premium(self, crown_entity: str, crown_data: Dict) -> float:
        """Calculate premium based on crown entity tier"""
        tier_premiums = {
            "ROYAL": 0.15,      # 15% premium
            "IMPERIAL": 0.10,   # 10% premium  
            "SOVEREIGN": 0.07,  # 7% premium
            "NOBLE": 0.03       # 3% premium
        }
        
        sovereign_bonus = 0.05 if crown_data["sovereign_backing"] else 0.0
        reserve_bonus = crown_data["reserve_ratio"] * 0.02
        
        return tier_premiums[crown_data["tier"]] + sovereign_bonus + reserve_bonus
    
    def generate_bond_versions(self, start_version: int = 1, end_version: int = 10000000) -> Generator[Dict, None, None]:
        """Generate Crown Holdings bonds from V1 to V10,000,000"""
        
        for version in range(start_version, end_version + 1):
            # Crown Holdings Assignment
            crown_entity, crown_data = self.get_crown_entity(version)
            crown_premium = self.calculate_crown_premium(crown_entity, crown_data)
            
            # Base bond generation
            base_seed = f"CROWN_BOND_V{version}"
            
            ns_index = version % len(self.namespaces)
            pattern_index = (version // len(self.namespaces)) % len(self.patterns)
            ext_index = (version // (len(self.namespaces) * len(self.patterns))) % len(self.extensions)
            
            namespace = self.namespaces[ns_index]
            pattern = self.patterns[pattern_index]
            extension = self.extensions[ext_index]
            
            # Generate unique bond hash with crown integration
            bond_hash = hashlib.sha256(
                f"{base_seed}{crown_entity}{namespace}{pattern}{extension}".encode()
            ).hexdigest()
            
            # Calculate maturity
            if extension == "2140":
                maturity = "2140-12-31"
                years = 2140 - datetime.now().year
            else:
                years = int(extension.replace('Y', ''))
                maturity = (datetime.now() + timedelta(days=years*365)).strftime("%Y-%m-%d")
            
            # Enhanced principal with crown premium
            principal_base = 1000
            principal = principal_base * (1 + (version % 100)) * (1 + crown_premium)
            
            # Enhanced interest rates with crown backing
            base_rates = {
                "SIMPLE": 0.02 + (version % 50) / 1000,
                "COMPOUND": 0.015 + (version % 30) / 1000,
                "ZERO": 0.0,
                "INFLATION": 0.01 + (version % 80) / 1000,
                "CALLABLE": 0.025 + (version % 40) / 1000,
                "CONVERTIBLE": 0.01 + (version % 20) / 1000,
                "PERPETUAL": 0.03 + (version % 25) / 1000,
                "RECURSIVE": 0.005 + (version % 100) / 1000