算法编导与用户叙事：YouTube AI定制内容流

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract AIDirectorStream is ERC721, AccessControl, ReentrancyGuard {
    bytes32 public constant AI_DIRECTOR_ROLE = keccak256("AI_DIRECTOR_ROLE");
    bytes32 public constant CREATOR_ROLE = keccak256("CREATOR_ROLE");
    bytes32 public constant VIEWER_ROLE = keccak256("VIEWER_ROLE");

    enum ContentType {
        VIDEO, SHORT, LIVESTREAM, PODCAST, MUSIC, ARTICLE, INTERACTIVE, AI_GENERATED
    }

    enum NarrativeRole {
        PROTAGONIST, ANTAGONIST, SUPPORTING, NARRATOR, BACKGROUND, CUSTOM
    }

    struct ContentNode {
        uint256 contentId;
        string title;
        string description;
        ContentType contentType;
        string ipfsCID;
        address creator;
        string[] tags;
        string[] emotions;
        uint256 duration;
        uint256 viewCount;
        uint256 engagementScore;
        bool isActive;
    }

    struct UserProfile {
        address user;
        string[] interests;
        string[] watchedContent;
        uint256 totalWatchTime;
        uint256 engagementScore;
        NarrativeRole preferredRole;
        string[] emotionHistory;
        uint256 lastActive;
    }

    struct AIStream {
        uint256 streamId;
        address viewer;
        uint256[] contentSequence;
        string currentNarrative;
        uint256 currentPosition;
        uint256 totalDuration;
        string[] branches;
        uint256 branchCount;
        bool isActive;
    }

    struct NarrativeBranch {
        uint256 branchId;
        uint256 streamId;
        string decision;
        uint256[] contentSequence;
        uint256 timestamp;
        uint256 viewerCount;
    }

    uint256 private _contentCounter;
    uint256 private _streamCounter;
    uint256 private _branchCounter;

    mapping(uint256 => ContentNode) public contentNodes;
    mapping(address => UserProfile) public userProfiles;
    mapping(uint256 => AIStream) public aiStreams;
    mapping(uint256 => NarrativeBranch[]) public streamBranches;
    mapping(address => uint256[]) public userStreams;

    uint256 public constant MIN_STAKE = 100 * 10**18;

    event ContentRegistered(uint256 indexed contentId, string title, address indexed creator);
    event StreamCreated(uint256 indexed streamId, address indexed viewer, uint256 contentCount);
    event BranchCreated(uint256 indexed branchId, uint256 indexed streamId, string decision);
    event NarrativeUpdated(uint256 indexed streamId, uint256 position, string newNarrative);
    event UserProfileUpdated(address indexed user, string[] interests);

    constructor() ERC721("AIDirectorStream", "AIDS") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function registerContent(
        string memory _title,
        string memory _description,
        ContentType _contentType,
        string memory _ipfsCID,
        string[] memory _tags,
        string[] memory _emotions,
        uint256 _duration
    ) external onlyRole(CREATOR_ROLE) returns (uint256) {
        uint256 contentId = _contentCounter++;
        contentNodes[contentId] = ContentNode({
            contentId: contentId,
            title: _title,
            description: _description,
            contentType: _contentType,
            ipfsCID: _ipfsCID,
            creator: msg.sender,
            tags: _tags,
            emotions: _emotions,
            duration: _duration,
            viewCount: 0,
            engagementScore: 0,
            isActive: true
        });
        emit ContentRegistered(contentId, _title, msg.sender);
        return contentId;
    }

    function updateUserProfile(
        string[] memory _interests,
        NarrativeRole _preferredRole
    ) external {
        UserProfile storage profile = userProfiles[msg.sender];
        if (profile.user == address(0)) {
            profile.user = msg.sender;
            profile.watchedContent = new string[](0);
            profile.emotionHistory = new string[](0);
            profile.totalWatchTime = 0;
            profile.engagementScore = 0;
        }
        profile.interests = _interests;
        profile.preferredRole = _preferredRole;
        profile.lastActive = block.timestamp;
        _grantRole(VIEWER_ROLE, msg.sender);
        emit UserProfileUpdated(msg.sender, _interests);
    }

    function createAIStream(
        address _viewer,
        uint256[] memory _contentSequence
    ) external onlyRole(AI_DIRECTOR_ROLE) returns (uint256) {
        uint256 streamId = _streamCounter++;
        uint256 totalDuration = 0;
        for (uint256 i = 0; i < _contentSequence.length; i++) {
            totalDuration += contentNodes[_contentSequence[i]].duration;
        }

        aiStreams[streamId] = AIStream({
            streamId: streamId,
            viewer: _viewer,
            contentSequence: _contentSequence,
            currentNarrative: "Opening",
            currentPosition: 0,
            totalDuration: totalDuration,
            branches: new string[](0),
            branchCount: 0,
            isActive: true
        });

        userStreams[_viewer].push(streamId);
        emit StreamCreated(streamId, _viewer, _contentSequence.length);
        return streamId;
    }

    function createBranch(
        uint256 _streamId,
        string memory _decision,
        uint256[] memory _contentSequence
    ) external onlyRole(AI_DIRECTOR_ROLE) returns (uint256) {
        AIStream storage stream = aiStreams[_streamId];
        require(stream.isActive, "Stream not active");

        uint256 branchId = _branchCounter++;
        NarrativeBranch memory branch = NarrativeBranch({
            branchId: branchId,
            streamId: _streamId,
            decision: _decision,
            contentSequence: _contentSequence,
            timestamp: block.timestamp,
            viewerCount: 0
        });
        streamBranches[_streamId].push(branch);
        stream.branches.push(_decision);
        stream.branchCount++;

        emit BranchCreated(branchId, _streamId, _decision);
        return branchId;
    }

    function advanceNarrative(uint256 _streamId, uint256 _newPosition) external {
        AIStream storage stream = aiStreams[_streamId];
        require(stream.viewer == msg.sender, "Not the viewer");
        require(_newPosition < stream.contentSequence.length, "Invalid position");
        stream.currentPosition = _newPosition;
        contentNodes[stream.contentSequence[_newPosition]].viewCount++;
        emit NarrativeUpdated(_streamId, _newPosition, "Advanced");
    }

    function getUserProfile(address _user) external view returns (UserProfile memory) {
        return userProfiles[_user];
    }

    function getStream(uint256 _streamId) external view returns (AIStream memory) {
        return aiStreams[_streamId];
    }

    function getStreamBranches(uint256 _streamId) external view returns (NarrativeBranch[] memory) {
        return streamBranches[_streamId];
    }

    function getUserStreams(address _user) external view returns (uint256[] memory) {
        return userStreams[_user];
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721, AccessControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

# AI Director - Personalized Content Stream Engine
# Algorithmic directing for YouTube-style content

import json
import random
import time
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum

class ContentType(Enum):
    VIDEO = "video"
    SHORT = "short"
    LIVESTREAM = "livestream"
    PODCAST = "podcast"
    MUSIC = "music"
    ARTICLE = "article"
    INTERACTIVE = "interactive"
    AI_GENERATED = "ai_generated"

class Emotion(Enum):
    HAPPY = "happy"
    SAD = "sad"
    EXCITED = "excited"
    CALM = "calm"
    ANXIOUS = "anxious"
    CURIOUS = "curious"
    NOSTALGIC = "nostalgic"
    INSPIRED = "inspired"

class NarrativeRole(Enum):
    PROTAGONIST = "protagonist"
    ANTAGONIST = "antagonist"
    SUPPORTING = "supporting"
    NARRATOR = "narrator"
    BACKGROUND = "background"
    CUSTOM = "custom"

@dataclass
class ContentNode:
    content_id: str
    title: str
    content_type: ContentType
    tags: List[str]
    emotions: List[Emotion]
    duration: int
    engagement_score: float
    narrative_arc: str  # opening, rising, climax, falling, resolution

@dataclass
class UserState:
    user_id: str
    interests: List[str]
    current_emotion: Emotion
    watch_history: List[str]
    total_watch_time: int
    engagement_score: float
    preferred_role: NarrativeRole
    time_of_day: str  # morning, afternoon, evening, night

@dataclass
class AIDirector:
    def __init__(self):
        self.content_library: Dict[str, ContentNode] = {}
        self.user_states: Dict[str, UserState] = {}
        self.streams: Dict[str, List[str]] = {}

    def register_content(self, content_id: str, title: str, content_type: ContentType,
                        tags: List[str], emotions: List[Emotion], duration: int,
                        narrative_arc: str) -> ContentNode:
        content = ContentNode(content_id=content_id, title=title, content_type=content_type,
                             tags=tags, emotions=emotions, duration=duration,
                             engagement_score=0.5, narrative_arc=narrative_arc)
        self.content_library[content_id] = content
        print(f"[CONTENT] Registered: {title}")
        return content

    def update_user_state(self, user_id: str, interests: List[str], emotion: Emotion,
                         time_of_day: str, preferred_role: NarrativeRole = NarrativeRole.PROTAGONIST):
        if user_id not in self.user_states:
            self.user_states[user_id] = UserState(user_id=user_id, interests=interests,
                                                 current_emotion=emotion, watch_history=[],
                                                 total_watch_time=0, engagement_score=0.5,
                                                 preferred_role=preferred_role, time_of_day=time_of_day)
        else:
            state = self.user_states[user_id]
            state.interests = interests
            state.current_emotion = emotion
            state.time_of_day = time_of_day
            state.preferred_role = preferred_role
        print(f"[USER] Updated: {user_id} ({emotion.value}, {time_of_day})")

    def generate_stream(self, user_id: str, max_duration: int = 3600) -> List[str]:
        if user_id not in self.user_states:
            raise ValueError(f"User {user_id} not found")
        state = self.user_states[user_id]

        # Filter content by user interests
        candidates = [c for c in self.content_library.values()
                     if any(tag in state.interests for tag in c.tags)]

        # Score content by emotion match
        scored = []
        for content in candidates:
            emotion_match = 1.0 if state.current_emotion in content.emotions else 0.3
            interest_score = len([t for t in content.tags if t in state.interests]) / max(len(content.tags), 1)
            arc_score = self._narrative_arc_score(content.narrative_arc, len(scored))
            total_score = (emotion_match * 0.4 + interest_score * 0.4 + arc_score * 0.2)
            scored.append((content, total_score))

        scored.sort(key=lambda x: x[1], reverse=True)

        # Build stream
        stream = []
        total_time = 0
        for content, score in scored:
            if total_time + content.duration > max_duration:
                break
            stream.append(content.content_id)
            total_time += content.duration

        self.streams[user_id] = stream
        print(f"[STREAM] Generated for {user_id}: {len(stream)} items ({total_time}s)")
        return stream

    def _narrative_arc_score(self, arc: str, position: int) -> float:
        arc_order = {"opening": 0, "rising": 1, "climax": 2, "falling": 3, "resolution": 4}
        ideal_position = arc_order.get(arc, 0) * len(self.content_library) // 5
        return 1.0 - abs(position - ideal_position) / max(len(self.content_library), 1)

    def create_branch(self, user_id: str, stream_id: str, decision: str) -> List[str]:
        if user_id not in self.streams:
            raise ValueError(f"No stream for {user_id}")
        current_stream = self.streams[user_id]

        # Create alternative path based on decision
        if decision == "more_action":
            branch = [c for c in current_stream if self.content_library[c].narrative_arc == "climax"]
        elif decision == "more_calm":
            branch = [c for c in current_stream if Emotion.CALM in self.content_library[c].emotions]
        else:
            branch = current_stream[:]

        print(f"[BRANCH] Created for {user_id}: {decision}")
        return branch

    def get_stream_narrative(self, user_id: str) -> Dict:
        if user_id not in self.streams:
            return {}
        stream = self.streams[user_id]
        narrative = {"user": user_id, "acts": []}
        for i, content_id in enumerate(stream):
            content = self.content_library[content_id]
            narrative["acts"].append({
                "position": i + 1,
                "title": content.title,
                "type": content.content_type.value,
                "arc": content.narrative_arc,
                "duration": content.duration
            })
        return narrative

# Example
director = AIDirector()

# Register content
director.register_content("v001", "Blockchain Explained", ContentType.VIDEO,
                         ["blockchain", "tech", "education"], [Emotion.CURIOUS, Emotion.INSPIRED],
                         600, "opening")
director.register_content("v002", "NFT Art Revolution", ContentType.VIDEO,
                         ["nft", "art", "blockchain"], [Emotion.EXCITED, Emotion.INSPIRED],
                         900, "rising")
director.register_content("v003", "DeFi Deep Dive", ContentType.VIDEO,
                         ["defi", "finance", "blockchain"], [Emotion.CURIOUS, Emotion.ANXIOUS],
                         1200, "climax")

# Update user state
director.update_user_state("user_001", ["blockchain", "nft", "tech"],
                          Emotion.CURIOUS, "evening", NarrativeRole.PROTAGONIST)

# Generate stream
stream = director.generate_stream("user_001", 1800)
narrative = director.get_stream_narrative("user_001")
print(f"Narrative: {json.dumps(narrative, indent=2, ensure_ascii=False)}")

# Create branch
branch = director.create_branch("user_001", "stream_001", "more_action")
print(f"Branch: {branch}")

// AI Director - Personalized Content Stream Engine
// Algorithmic directing with ethical considerations

class AIDirector {
    constructor() {
        this.contentLibrary = new Map();
        this.userStates = new Map();
        this.streams = new Map();
        this.ethicalConstraints = {
            maxWatchTime: 7200, // 2 hours
            diversityThreshold: 0.3,
            emotionManipulation: false
        };
    }

    registerContent(contentId, title, contentType, tags, emotions, duration, narrativeArc) {
        const content = { contentId, title, contentType, tags, emotions, duration,
            engagementScore: 0.5, narrativeArc };
        this.contentLibrary.set(contentId, content);
        console.log(`[CONTENT] Registered: ${title}`);
        return content;
    }

    updateUserState(userId, interests, emotion, timeOfDay, preferredRole = 'protagonist') {
        let state = this.userStates.get(userId);
        if (!state) {
            state = { userId, interests, currentEmotion: emotion, watchHistory: [],
                totalWatchTime: 0, engagementScore: 0.5, preferredRole, timeOfDay };
        } else {
            state.interests = interests;
            state.currentEmotion = emotion;
            state.timeOfDay = timeOfDay;
            state.preferredRole = preferredRole;
        }
        this.userStates.set(userId, state);
        console.log(`[USER] Updated: ${userId} (${emotion}, ${timeOfDay})`);
    }

    generateStream(userId, maxDuration = 3600) {
        const state = this.userStates.get(userId);
        if (!state) throw new Error('User not found');

        const candidates = [...this.contentLibrary.values()]
            .filter(c => c.tags.some(t => state.interests.includes(t)));

        const scored = candidates.map(content => {
            const emotionMatch = content.emotions.includes(state.currentEmotion) ? 1.0 : 0.3;
            const interestScore = content.tags.filter(t => state.interests.includes(t)).length / Math.max(content.tags.length, 1);
            return { content, score: emotionMatch * 0.4 + interestScore * 0.4 + 0.2 };
        }).sort((a, b) => b.score - a.score);

        const stream = [];
        let totalTime = 0;
        for (const { content } of scored) {
            if (totalTime + content.duration > maxDuration) break;
            stream.push(content.contentId);
            totalTime += content.duration;
        }

        this.streams.set(userId, stream);
        console.log(`[STREAM] Generated for ${userId}: ${stream.length} items (${totalTime}s)`);
        return stream;
    }

    createBranch(userId, decision) {
        const stream = this.streams.get(userId);
        if (!stream) throw new Error('No stream found');
        const library = this.contentLibrary;

        let branch;
        if (decision === 'more_action') {
            branch = stream.filter(id => library.get(id).narrativeArc === 'climax');
        } else if (decision === 'more_calm') {
            branch = stream.filter(id => library.get(id).emotions.includes('calm'));
        } else {
            branch = [...stream];
        }
        console.log(`[BRANCH] Created for ${userId}: ${decision}`);
        return branch;
    }

    getStreamNarrative(userId) {
        const stream = this.streams.get(userId);
        if (!stream) return {};
        const narrative = { user: userId, acts: [] };
        stream.forEach((id, i) => {
            const content = this.contentLibrary.get(id);
            narrative.acts.push({ position: i + 1, title: content.title,
                type: content.contentType, arc: content.narrativeArc, duration: content.duration });
        });
        return narrative;
    }
}

// Example
const director = new AIDirector();
director.registerContent('v001', 'Blockchain Explained', 'video', ['blockchain', 'tech'], ['curious'], 600, 'opening');
director.registerContent('v002', 'NFT Art Revolution', 'video', ['nft', 'art'], ['excited'], 900, 'rising');
director.registerContent('v003', 'DeFi Deep Dive', 'video', ['defi', 'finance'], ['curious'], 1200, 'climax');
director.updateUserState('user_001', ['blockchain', 'nft', 'tech'], 'curious', 'evening');
director.generateStream('user_001', 1800);
console.log('Narrative:', JSON.stringify(director.getStreamNarrative('user_001'), null, 2));