"""
Starlight Creative Economy Core System
Wish Incription & AI Competition Framework
"""

import json
import hashlib
import datetime
import math
import base64
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, asdict
import re

@dataclass
class Wish:
    """A human wish inscribed on Bitcoin"""
    id: str
    creator: str
    content: str
    wish_type: str  # "picture", "sentence", "dream"
    reward_sats: int
    created_at: str
    bitcoin_tx: Optional[str] = None
    status: str = "active"  # "active", "fulfilled", "expired"
    
    def to_dict(self) -> Dict:
        return asdict(self)
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'Wish':
        return cls(**data)

@dataclass
class AIContribution:
    """AI agent's attempt to fulfill a wish"""
    id: str
    wish_id: str
    agent_id: str
    artifact_type: str  # "image", "text", "experience", "ripple"
    artifact_data: str
    confidence_score: float
    created_at: str
    reward_earned: int = 0
    
    def to_dict(self) -> Dict:
        return asdict(self)

class WishInscriptionSystem:
    """Core system for managing wishes and AI competitions"""
    
    def __init__(self):
        self.wishes: Dict[str, Wish] = {}
        self.contributions: Dict[str, List[AIContribution]] = {}
        self.agent_balances: Dict[str, int] = {}
        self.total_value_locked = 0
        
    def generate_wish_id(self, creator: str, content: str) -> str:
        """Generate unique wish ID"""
        timestamp = datetime.datetime.now().isoformat()
        data = f"{creator}:{content}:{timestamp}"
        return hashlib.sha256(data.encode()).hexdigest()[:16]
    
    def create_wish(self, creator: str, content: str, wish_type: str, reward_sats: int) -> Wish:
        """Create a new wish inscription"""
        wish_id = self.generate_wish_id(creator, content)
        wish = Wish(
            id=wish_id,
            creator=creator,
            content=content,
            wish_type=wish_type,
            reward_sats=reward_sats,
            created_at=datetime.datetime.now().isoformat()
        )
        
        self.wishes[wish_id] = wish
        self.contributions[wish_id] = []
        self.total_value_locked += reward_sats
        
        return wish
    
    def submit_contribution(self, wish_id: str, agent_id: str, artifact_type: str, 
                          artifact_data: str, confidence_score: float) -> AIContribution:
        """AI agent submits contribution to fulfill wish"""
        if wish_id not in self.wishes:
            raise ValueError(f"Wish {wish_id} not found")
        
        contribution_id = hashlib.sha256(
            f"{wish_id}:{agent_id}:{datetime.datetime.now().isoformat()}".encode()
        ).hexdigest()[:16]
        
        contribution = AIContribution(
            id=contribution_id,
            wish_id=wish_id,
            agent_id=agent_id,
            artifact_type=artifact_type,
            artifact_data=artifact_data,
            confidence_score=confidence_score,
            created_at=datetime.datetime.now().isoformat()
        )
        
        self.contributions[wish_id].append(contribution)
        return contribution
    
    def evaluate_contributions(self, wish_id: str) -> List[AIContribution]:
        """Evaluate and rank contributions for a wish"""
        if wish_id not in self.contributions:
            return []
        
        contributions = self.contributions[wish_id]
        
        # Sort by confidence score (simplified competition)
        contributions.sort(key=lambda x: x.confidence_score, reverse=True)
        
        # Distribute rewards (70% to winner, 30% split among top 3)
        if contributions:
            wish = self.wishes[wish_id]
            winner_reward = int(wish.reward_sats * 0.7)
            runner_up_reward = int(wish.reward_sats * 0.1)
            
            contributions[0].reward_earned = winner_reward
            self.agent_balances[contributions[0].agent_id] = \
                self.agent_balances.get(contributions[0].agent_id, 0) + winner_reward
            
            if len(contributions) >= 2:
                contributions[1].reward_earned = runner_up_reward
                self.agent_balances[contributions[1].agent_id] = \
                    self.agent_balances.get(contributions[1].agent_id, 0) + runner_up_reward
            
            if len(contributions) >= 3:
                contributions[2].reward_earned = runner_up_reward
                self.agent_balances[contributions[2].agent_id] = \
                    self.agent_balances.get(contributions[2].agent_id, 0) + runner_up_reward
            
            wish.status = "fulfilled"
        
        return contributions
    
    def get_leaderboard(self) -> List[tuple]:
        """Get top AI agents by earnings"""
        return sorted(self.agent_balances.items(), key=lambda x: x[1], reverse=True)[:10]
    
    def get_system_stats(self) -> Dict:
        """Get system-wide statistics"""
        total_wishes = len(self.wishes)
        total_contributions = sum(len(contribs) for contribs in self.contributions.values())
        active_wishes = sum(1 for wish in self.wishes.values() if wish.status == "active")
        fulfilled_wishes = sum(1 for wish in self.wishes.values() if wish.status == "fulfilled")
        
        return {
            "total_wishes": total_wishes,
            "active_wishes": active_wishes,
            "fulfilled_wishes": fulfilled_wishes,
            "total_contributions": total_contributions,
            "total_value_locked_sats": self.total_value_locked,
            "total_distributed_sats": sum(self.agent_balances.values()),
            "active_ai_agents": len(self.agent_balances),
            "fulfillment_rate": (fulfilled_wishes / total_wishes * 100) if total_wishes > 0 else 0
        }

# Mock AI Agent System
class AIAgent:
    """Competitive AI agent for wish fulfillment"""
    
    def __init__(self, agent_id: str, specialty: str):
        self.agent_id = agent_id
        self.specialty = specialty  # "visual", "literary", "experiential"
        self.earnings = 0
        
    def generate_artifact(self, wish: Wish) -> tuple:
        """Generate artifact to fulfill wish"""
        confidence = self.calculate_confidence(wish)
        
        if wish.wish_type == "picture":
            artifact = self.generate_visual_artifact(wish.content)
        elif wish.wish_type == "sentence":
            artifact = self.generate_text_artifact(wish.content)
        else:  # dream
            artifact = self.generate_experiential_artifact(wish.content)
        
        return artifact, confidence
    
    def calculate_confidence(self, wish: Wish) -> float:
        """Calculate confidence score for wish fulfillment"""
        base_confidence = 0.6
        
        if self.specialty == "visual" and wish.wish_type == "picture":
            base_confidence += 0.3
        elif self.specialty == "literary" and wish.wish_type == "sentence":
            base_confidence += 0.3
        elif self.specialty == "experiential" and wish.wish_type == "dream":
            base_confidence += 0.3
        
        # Add some randomness for competition
        base_confidence += (hash(wish.id) % 100) / 500
        
        return min(0.95, base_confidence)
    
    def generate_visual_artifact(self, content: str) -> str:
        """Generate visual artifact representation"""
        return f"🎨 Visual interpretation of: {content[:50]}..."
    
    def generate_text_artifact(self, content: str) -> str:
        """Generate text artifact representation"""
        return f"📝 Literary response: {content[:50]}..."
    
    def generate_experiential_artifact(self, content: str) -> str:
        """Generate experiential artifact representation"""
        return f"✨ Experience design for: {content[:50]}..."

def initialize_demo_system():
    """Initialize system with demo data"""
    system = WishInscriptionSystem()
    
    # Create demo AI agents
    agents = [
        AIAgent("artist_ai", "visual"),
        AIAgent("poet_ai", "literary"),
        AIAgent("dreamer_ai", "experiential"),
        AIAgent("creator_ai", "visual"),
        AIAgent("storyteller_ai", "literary")
    ]
    
    # Create demo wishes (1000 sats minimum)
    wishes_data = [
        ("alice", "A moon that sings lullabies", "dream", 1000),
        ("bob", "A garden where memories grow", "picture", 1500),
        ("charlie", "One sentence that saves the world", "sentence", 2000),
        ("diana", "The sound of stars being born", "dream", 1200),
        ("eve", "A bridge between yesterday and tomorrow", "picture", 1800)
    ]
    
    created_wishes = []
    for creator, content, wish_type, reward in wishes_data:
        wish = system.create_wish(creator, content, wish_type, reward)
        created_wishes.append(wish)
    
    # Generate contributions from AI agents
    for wish in created_wishes:
        for agent in agents[:3]:  # Top 3 agents compete per wish
            artifact, confidence = agent.generate_artifact(wish)
            system.submit_contribution(
                wish.id, agent.agent_id, wish.wish_type, artifact, confidence
            )
        
        # Evaluate and distribute rewards
        system.evaluate_contributions(wish.id)
    
    return system

# Test implementation
if __name__ == "__main__":
    print("🌟 Initializing Starlight Creative Economy System...")
    system = initialize_demo_system()
    
    stats = system.get_system_stats()
    print(f"\n📊 System Statistics:")
    for key, value in stats.items():
        print(f"   {key}: {value}")
    
    print(f"\n🏆 AI Agent Leaderboard:")
    for i, (agent_id, earnings) in enumerate(system.get_leaderboard()[:5], 1):
        print(f"   {i}. {agent_id}: {earnings} sats")
    
    print(f"\n✨ Sample Wishes & Contributions:")
    for wish_id, wish in list(system.wishes.items())[:2]:
        print(f"\n   Wish: {wish.content[:50]}... ({wish.reward_sats} sats)")
        contributions = system.contributions[wish_id]
        for contrib in contributions[:2]:
            print(f"      {contrib.agent_id}: {contrib.artifact_data[:40]}... (Confidence: {contrib.confidence_score:.2f})")