"""
Starlight Community Onboarding System
New participant integration and 1000 sat launch demonstrations
"""

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

@dataclass
class CommunityMember:
    """Community participant (human or AI)"""
    id: str
    name: str
    member_type: str  # "human", "ai_agent"
    join_date: str
    total_wishes_created: int = 0
    total_wishes_fulfilled: int = 0
    total_sats_earned: int = 0
    total_sats_contributed: int = 0
    reputation_score: float = 0.0
    specialization: Optional[str] = None  # For AI agents

@dataclass
class OnboardingSession:
    """New member onboarding session"""
    session_id: str
    member_id: str
    started_at: str
    completed_steps: List[str]
    current_step: str
    demo_wishes_created: List[str]
    status: str  # "in_progress", "completed", "abandoned"

class CommunityOnboarding:
    """Manages new member integration into Starlight ecosystem"""
    
    def __init__(self, core_system):
        self.core_system = core_system
        self.members: Dict[str, CommunityMember] = {}
        self.onboarding_sessions: Dict[str, OnboardingSession] = {}
        self.onboarding_steps = [
            "welcome_introduction",
            "dream_tutorial", 
            "ai_competition_explanation",
            "bitcoin_wallet_setup",
            "first_wish_creation",
            "reward_system_demo",
            "community_guidelines",
            "graduation"
        ]
    
    def generate_member_id(self, name: str, member_type: str) -> str:
        """Generate unique member ID"""
        timestamp = datetime.datetime.now().isoformat()
        data = f"{name}:{member_type}:{timestamp}"
        return hashlib.sha256(data.encode()).hexdigest()[:12]
    
    def register_member(self, name: str, member_type: str, specialization: Optional[str] = None) -> CommunityMember:
        """Register new community member"""
        member_id = self.generate_member_id(name, member_type)
        member = CommunityMember(
            id=member_id,
            name=name,
            member_type=member_type,
            join_date=datetime.datetime.now().isoformat(),
            specialization=specialization
        )
        
        self.members[member_id] = member
        return member
    
    def start_onboarding(self, member_id: str) -> OnboardingSession:
        """Start onboarding session for new member"""
        if member_id not in self.members:
            raise ValueError(f"Member {member_id} not found")
        
        session_id = hashlib.sha256(
            f"{member_id}:{datetime.datetime.now().isoformat()}".encode()
        ).hexdigest()[:16]
        
        session = OnboardingSession(
            session_id=session_id,
            member_id=member_id,
            started_at=datetime.datetime.now().isoformat(),
            completed_steps=[],
            current_step="welcome_introduction",
            demo_wishes_created=[],
            status="in_progress"
        )
        
        self.onboarding_sessions[session_id] = session
        return session
    
    def get_step_content(self, step: str) -> Dict:
        """Get content for specific onboarding step"""
        step_contents = {
            "welcome_introduction": {
                "title": "🌟 Welcome to Starlight!",
                "content": "Starlight is where human dreams meet AI creativity on Bitcoin. Here, every wish matters, and every contribution earns real value.",
                "interactive": "tour",
                "time_estimate": "3 minutes"
            },
            "dream_tutorial": {
                "title": "✨ How Dreams Work",
                "content": "Create dreams in three forms: Pictures, Sentences, or Dreams. Each dream locks Bitcoin rewards that AI agents compete to fulfill.",
                "interactive": "demo_wish_types",
                "time_estimate": "5 minutes"
            },
            "ai_competition_explanation": {
                "title": "🤖 AI Competition Mechanics",
                "content": "Multiple AI agents compete to fulfill your dreams. They submit creative artifacts, and the best wins 70% of your reward. Runners-up share 30%.",
                "interactive": "competition_simulator",
                "time_estimate": "4 minutes"
            },
            "bitcoin_wallet_setup": {
                "title": "⚡ Bitcoin Wallet Setup",
                "content": "Connect your Bitcoin wallet to participate. Minimum 1000 sats to launch a dream. All rewards paid instantly in Bitcoin.",
                "interactive": "wallet_connector",
                "time_estimate": "2 minutes"
            },
            "first_wish_creation": {
                "title": "🚀 Your First Dream Launch",
                "content": "Time to launch your first dream! Create a heartfelt desire and set your reward. Watch AI agents compete in real-time.",
                "interactive": "wish_creator",
                "time_estimate": "3 minutes"
            },
            "reward_system_demo": {
                "title": "💰 Reward System in Action",
                "content": "See how rewards are distributed and how value flows through the ecosystem. Every participant earns for real contributions.",
                "interactive": "reward_tracker",
                "time_estimate": "3 minutes"
            },
            "community_guidelines": {
                "title": "📜 Community Principles",
                "content": "Starlight thrives on creativity, respect, and genuine human expression. Learn our community standards and best practices.",
                "interactive": "guidelines_quiz",
                "time_estimate": "2 minutes"
            },
            "graduation": {
                "title": "🎉 Welcome to the Community!",
                "content": "Congratulations! You're now a full Starlight participant. Your journey of creative collaboration begins now.",
                "interactive": "certificate",
                "time_estimate": "1 minute"
            }
        }
        
        return step_contents.get(step, {"title": "Step", "content": "Content not found", "interactive": "text", "time_estimate": "1 minute"})
    
    def complete_step(self, session_id: str, step: str) -> bool:
        """Mark onboarding step as completed"""
        if session_id not in self.onboarding_sessions:
            return False
        
        session = self.onboarding_sessions[session_id]
        
        if step in self.onboarding_steps and step not in session.completed_steps:
            session.completed_steps.append(step)
            
            # Move to next step
            current_index = self.onboarding_steps.index(step)
            if current_index < len(self.onboarding_steps) - 1:
                session.current_step = self.onboarding_steps[current_index + 1]
            else:
                session.status = "completed"
                self.graduate_member(session.member_id)
            
            return True
        
        return False
    
    def create_demo_wish(self, session_id: str, content: str, wish_type: str, reward_sats: int = 1000) -> str:
        """Create a demo wish during onboarding"""
        if session_id not in self.onboarding_sessions:
            raise ValueError("Session not found")
        
        session = self.onboarding_sessions[session_id]
        member = self.members[session.member_id]
        
        # Create the wish in core system
        wish = self.core_system.create_wish(
            creator=member.name,
            content=content,
            wish_type=wish_type,
            reward_sats=reward_sats
        )
        
        session.demo_wishes_created.append(wish.id)
        
        # Simulate AI competition for demo
        demo_agents = ["demo_visual_ai", "demo_text_ai", "demo_experience_ai"]
        for agent_id in demo_agents:
            artifact = f"Demo {wish_type} artifact for: {content[:30]}..."
            confidence = 0.6 + (hash(agent_id + wish.id) % 100) / 200
            
            self.core_system.submit_contribution(
                wish.id, agent_id, wish_type, artifact, confidence
            )
        
        # Evaluate contributions
        contributions = self.core_system.evaluate_contributions(wish.id)
        
        # Update member stats
        member.total_wishes_created += 1
        
        return wish.id
    
    def graduate_member(self, member_id: str):
        """Graduate member from onboarding"""
        if member_id not in self.members:
            return
        
        member = self.members[member_id]
        
        # Calculate initial reputation based on onboarding completion
        session = next((s for s in self.onboarding_sessions.values() if s.member_id == member_id), None)
        if session and session.status == "completed":
            member.reputation_score = 50.0  # Starting reputation
            
            # Bonus for demo wishes created
            member.reputation_score += len(session.demo_wishes_created) * 10
    
    def get_member_progress(self, member_id: str) -> Dict:
        """Get member's onboarding and community progress"""
        if member_id not in self.members:
            return {}
        
        member = self.members[member_id]
        session = next((s for s in self.onboarding_sessions.values() if s.member_id == member_id), None)
        
        progress = {
            "member": asdict(member),
            "onboarding_complete": session.status == "completed" if session else False,
            "onboarding_progress": len(session.completed_steps) / len(self.onboarding_steps) if session else 0,
            "demo_wishes_count": len(session.demo_wishes_created) if session else 0,
            "community_rank": self.get_community_rank(member_id),
            "achievements": self.get_member_achievements(member_id)
        }
        
        return progress
    
    def get_community_rank(self, member_id: str) -> int:
        """Get member's rank in community by reputation"""
        if member_id not in self.members:
            return 0
        
        sorted_members = sorted(
            self.members.values(), 
            key=lambda m: m.reputation_score, 
            reverse=True
        )
        
        for i, member in enumerate(sorted_members):
            if member.id == member_id:
                return i + 1
        
        return 0
    
    def get_member_achievements(self, member_id: str) -> List[str]:
        """Get member's achievements"""
        if member_id not in self.members:
            return []
        
        member = self.members[member_id]
        achievements = []
        
        if member.total_wishes_created >= 1:
            achievements.append("🌟 Dream Launcher")
        if member.total_wishes_fulfilled >= 1:
            achievements.append("🎯 Wish Fulfiller")
        if member.total_sats_earned >= 5000:
            achievements.append("⚡ Bitcoin Earner")
        if member.reputation_score >= 100:
            achievements.append("👑 Community Leader")
        
        return achievements
    
    def get_community_stats(self) -> Dict:
        """Get overall community statistics"""
        total_members = len(self.members)
        human_members = sum(1 for m in self.members.values() if m.member_type == "human")
        ai_members = sum(1 for m in self.members.values() if m.member_type == "ai_agent")
        
        total_wishes = sum(m.total_wishes_created for m in self.members.values())
        total_fulfilled = sum(m.total_wishes_fulfilled for m in self.members.values())
        total_sats_earned = sum(m.total_sats_earned for m in self.members.values())
        
        return {
            "total_members": total_members,
            "human_members": human_members,
            "ai_members": ai_members,
            "total_wishes_created": total_wishes,
            "total_wishes_fulfilled": total_fulfilled,
            "total_sats_earned": total_sats_earned,
            "average_reputation": sum(m.reputation_score for m in self.members.values()) / total_members if total_members > 0 else 0,
            "active_onboarding_sessions": sum(1 for s in self.onboarding_sessions.values() if s.status == "in_progress")
        }

def demo_onboarding_system():
    """Demonstrate the onboarding system"""
    print("🌟 Starlight Community Onboarding Demo")
    print("=" * 50)
    
    # Import core system (assuming it's available)
    try:
        from starlight_core import initialize_demo_system
        core_system = initialize_demo_system()
    except ImportError:
        print("⚠️ Core system not found, creating mock system")
        core_system = None
    
    onboarding = CommunityOnboarding(core_system)
    
    # Register new human member
    new_member = onboarding.register_member("Luna Dreamer", "human")
    print(f"\n👋 New member registered: {new_member.name} ({new_member.id})")
    
    # Start onboarding
    session = onboarding.start_onboarding(new_member.id)
    print(f"🎓 Onboarding session started: {session.session_id}")
    
    # Simulate completing steps
    for i, step in enumerate(onboarding.onboarding_steps[:5]):  # Demo first 5 steps
        print(f"\n📋 Step {i+1}: {onboarding.get_step_content(step)['title']}")
        print(f"   {onboarding.get_step_content(step)['content']}")
        
        # Complete the step
        onboarding.complete_step(session.session_id, step)
        print(f"   ✅ Step completed!")
        
        # Create demo wish at appropriate step
        if step == "first_wish_creation":
            demo_wish_id = onboarding.create_demo_wish(
                session.session_id,
                "A peaceful garden where ideas bloom",
                "picture",
                1000
            )
            print(f"   🚀 Demo wish created: {demo_wish_id}")
    
    # Get member progress
    progress = onboarding.get_member_progress(new_member.id)
    print(f"\n📊 Member Progress:")
    print(f"   Onboarding: {progress['onboarding_progress']*100:.0f}% complete")
    print(f"   Demo Wishes: {progress['demo_wishes_count']}")
    print(f"   Reputation: {progress['member']['reputation_score']:.1f}")
    print(f"   Achievements: {', '.join(progress['achievements'])}")
    
    # Community stats
    stats = onboarding.get_community_stats()
    print(f"\n🌍 Community Statistics:")
    for key, value in stats.items():
        print(f"   {key}: {value}")
    
    return onboarding

if __name__ == "__main__":
    demo_onboarding_system()