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

contract ClapperBoard {

    enum NarrativeRole {
        Protagonist,
        Antagonist,
        Supporting,
        Narrator,
        Extra
    }

    enum EventCategory {
        TokenTransfer,
        DeFiSwap,
        Liquidation,
        GovernanceVote,
        BridgeCross,
        NFTMint,
        ContractDeploy,
        Custom
    }

    struct SceneRecord {
        uint256 sceneId;
        uint256 parentId;
        address director;
        address[] cast;
        EventCategory category;
        NarrativeRole role;
        string intent;
        string context;
        uint256 blockTimestamp;
        uint256 gasConsumed;
        bytes32 relatedTxHash;
        bytes32[] crossReferences;
        bool isFinalCut;
    }

    struct NarrativeArc {
        uint256 arcId;
        string title;
        string synopsis;
        uint256[] sceneIds;
        address author;
        uint256 startBlock;
        uint256 endBlock;
        string genre;
        uint8 actCount;
        uint256 createdAt;
    }

    uint256 private _sceneCounter;
    uint256 private _arcCounter;

    mapping(uint256 => SceneRecord) private _scenes;
    mapping(uint256 => NarrativeArc) private _arcs;
    mapping(address => uint256[]) private _directorFilmography;
    mapping(bytes32 => uint256) private _txHashToScene;
    mapping(uint256 => uint256[]) private _arcScenes;
    mapping(string => uint256[]) private _genreIndex;

    event SceneShot(
        uint256 indexed sceneId,
        uint256 indexed parentId,
        address indexed director,
        EventCategory category,
        NarrativeRole role,
        uint256 blockTimestamp
    );

    event NarrativeArcCreated(
        uint256 indexed arcId,
        string title,
        address indexed author,
        string genre
    );

    event SceneLinkedToArc(
        uint256 indexed sceneId,
        uint256 indexed arcId
    );

    event DirectorCutFinalized(
        uint256 indexed sceneId,
        address indexed director
    );

    modifier onlyDirector(uint256 sceneId) {
        require(
            _scenes[sceneId].director == msg.sender,
            "ClapperBoard: caller is not the director of this scene"
        );
        _;
    }

    modifier sceneExists(uint256 sceneId) {
        require(
            _scenes[sceneId].blockTimestamp > 0,
            "ClapperBoard: scene does not exist"
        );
        _;
    }

    function shootScene(
        uint256 parentId,
        address[] memory cast,
        EventCategory category,
        NarrativeRole role,
        string memory intent,
        string memory context,
        bytes32 relatedTxHash,
        bytes32[] memory crossReferences
    ) external returns (uint256) {
        _sceneCounter++;
        uint256 newSceneId = _sceneCounter;

        _scenes[newSceneId] = SceneRecord({
            sceneId: newSceneId,
            parentId: parentId,
            director: msg.sender,
            cast: cast,
            category: category,
            role: role,
            intent: intent,
            context: context,
            blockTimestamp: block.timestamp,
            gasConsumed: gasleft(),
            relatedTxHash: relatedTxHash,
            crossReferences: crossReferences,
            isFinalCut: false
        });

        _directorFilmography[msg.sender].push(newSceneId);

        if (relatedTxHash != bytes32(0)) {
            _txHashToScene[relatedTxHash] = newSceneId;
        }

        emit SceneShot(
            newSceneId,
            parentId,
            msg.sender,
            category,
            role,
            block.timestamp
        );

        return newSceneId;
    }

    function finalizeCut(
        uint256 sceneId
    ) external onlyDirector(sceneId) sceneExists(sceneId) {
        require(
            !_scenes[sceneId].isFinalCut,
            "ClapperBoard: scene already finalized"
        );
        _scenes[sceneId].isFinalCut = true;
        _scenes[sceneId].gasConsumed = gasleft();
        emit DirectorCutFinalized(sceneId, msg.sender);
    }

    function createNarrativeArc(
        string memory title,
        string memory synopsis,
        uint256[] memory sceneIds,
        string memory genre,
        uint8 actCount
    ) external returns (uint256) {
        _arcCounter++;
        uint256 newArcId = _arcCounter;

        uint256 startBlock = type(uint256).max;
        uint256 endBlock = 0;

        for (uint256 i = 0; i < sceneIds.length; i++) {
            require(
                _scenes[sceneIds[i]].blockTimestamp > 0,
                "ClapperBoard: referenced scene does not exist"
            );
            _arcScenes[newArcId].push(sceneIds[i]);
        }

        _arcs[newArcId] = NarrativeArc({
            arcId: newArcId,
            title: title,
            synopsis: synopsis,
            sceneIds: sceneIds,
            author: msg.sender,
            startBlock: startBlock,
            endBlock: endBlock,
            genre: genre,
            actCount: actCount,
            createdAt: block.timestamp
        });

        _genreIndex[genre].push(newArcId);

        emit NarrativeArcCreated(newArcId, title, msg.sender, genre);

        return newArcId;
    }

    function linkSceneToArc(
        uint256 sceneId,
        uint256 arcId
    ) external sceneExists(sceneId) {
        require(
            _arcs[arcId].createdAt > 0,
            "ClapperBoard: narrative arc does not exist"
        );
        _arcScenes[arcId].push(sceneId);
        emit SceneLinkedToArc(sceneId, arcId);
    }

    function getScene(
        uint256 sceneId
    ) external view sceneExists(sceneId) returns (SceneRecord memory) {
        return _scenes[sceneId];
    }

    function getNarrativeArc(
        uint256 arcId
    ) external view returns (NarrativeArc memory) {
        require(
            _arcs[arcId].createdAt > 0,
            "ClapperBoard: narrative arc does not exist"
        );
        return _arcs[arcId];
    }

    function getDirectorFilmography(
        address director
    ) external view returns (uint256[] memory) {
        return _directorFilmography[director];
    }

    function getScenesByTxHash(
        bytes32 txHash
    ) external view returns (uint256) {
        return _txHashToScene[txHash];
    }

    function getArcsByGenre(
        string memory genre
    ) external view returns (uint256[] memory) {
        return _genreIndex[genre];
    }

    function getArcSceneCount(
        uint256 arcId
    ) external view returns (uint256) {
        return _arcScenes[arcId].length;
    }
}

const { ethers } = require("ethers");
const OpenAI = require("openai");
const fs = require("fs").promises;

const CLAPPERBOARD_ABI = [
  "event SceneShot(uint256 indexed sceneId, uint256 indexed parentId, address indexed director, uint8 category, uint8 role, uint256 blockTimestamp)",
  "event NarrativeArcCreated(uint256 indexed arcId, string title, address indexed author, string genre)",
  "event DirectorCutFinalized(uint256 indexed sceneId, address indexed director)",
  "function getScene(uint256 sceneId) view returns (tuple(uint256 sceneId, uint256 parentId, address director, address[] cast, uint8 category, uint8 role, string intent, string context, uint256 blockTimestamp, uint256 gasConsumed, bytes32 relatedTxHash, bytes32[] crossReferences, bool isFinalCut))",
  "function getNarrativeArc(uint256 arcId) view returns (tuple(uint256 arcId, string title, string synopsis, uint256[] sceneIds, address author, uint256 startBlock, uint256 endBlock, string genre, uint8 actCount, uint256 createdAt))"
];

const CATEGORY_LABELS = {
  0: "TokenTransfer", 1: "DeFiSwap", 2: "Liquidation",
  3: "GovernanceVote", 4: "BridgeCross", 5: "NFTMint",
  6: "ContractDeploy", 7: "Custom"
};

const ROLE_LABELS = {
  0: "Protagonist", 1: "Antagonist", 2: "Supporting",
  3: "Narrator", 4: "Extra"
};

class NarrativeEngine {
  constructor(rpcUrl, contractAddress, openaiApiKey) {
    this.provider = new ethers.JsonRpcProvider(rpcUrl);
    this.contract = new ethers.Contract(contractAddress, CLAPPERBOARD_ABI, this.provider);
    this.ai = new OpenAI({ apiKey: openaiApiKey });
    this.sceneBuffer = [];
    this.arcIndex = new Map();
    this.timelineCache = new Map();
  }

  async collectScenes(fromBlock, toBlock) {
    const filter = this.contract.filters.SceneShot();
    const events = await this.contract.queryFilter(filter, fromBlock, toBlock);

    for (const event of events) {
      const sceneId = Number(event.args.sceneId);
      const scene = await this.contract.getScene(sceneId);
      this.sceneBuffer.push({
        sceneId: sceneId,
        parentId: Number(scene.parentId),
        director: scene.director,
        cast: scene.cast,
        category: CATEGORY_LABELS[Number(scene.category)],
        role: ROLE_LABELS[Number(scene.role)],
        intent: scene.intent,
        context: scene.context,
        timestamp: Number(scene.blockTimestamp),
        gasConsumed: scene.gasConsumed.toString(),
        relatedTxHash: scene.relatedTxHash,
        crossReferences: scene.crossReferences,
        blockNumber: event.blockNumber,
        isFinalCut: scene.isFinalCut
      });
    }

    this.sceneBuffer.sort((a, b) => a.timestamp - b.timestamp);
    return this.sceneBuffer.length;
  }

  async generateNarrativeSummary(scenes) {
    const condensed = scenes.map(s => ({
      id: s.sceneId,
      type: s.category,
      director: s.director.slice(0, 10),
      actors: s.cast.length,
      intent: s.intent,
      time: new Date(s.timestamp * 1000).toISOString(),
      role: s.role,
      context: s.context
    }));

    const response = await this.ai.chat.completions.create({
      model: "gpt-4o",
      messages: [
        {
          role: "system",
          content: "You are a blockchain narrative analyst who interprets on-chain events as cinematic storylines. Output JSON with fields: episodeTitle, synopsis, keyBeats (array of {sceneId, narrativeFunction, emotionalTone}), foreshadowing (array), climax (object with sceneId and description), genreClassification."
        },
        {
          role: "user",
          content: `Analyze the following ${condensed.length} blockchain scenes as a narrative sequence:\n${JSON.stringify(condensed, null, 2)}`
        }
      ],
      response_format: { type: "json_object" },
      temperature: 0.4
    });

    return JSON.parse(response.choices[0].message.content);
  }

  buildTimelineTree(scenes) {
    const roots = [];
    const nodeMap = new Map();

    for (const scene of scenes) {
      nodeMap.set(scene.sceneId, { scene, children: [] });
    }

    for (const scene of scenes) {
      const node = nodeMap.get(scene.sceneId);
      if (scene.parentId === 0) {
        roots.push(node);
      } else if (nodeMap.has(scene.parentId)) {
        nodeMap.get(scene.parentId).children.push(node);
      } else {
        roots.push(node);
      }
    }

    return roots;
  }

  detectRecurringPatterns(scenes) {
    const directorCounts = {};
    const categoryCounts = {};
    const hourlyBuckets = {};

    for (const scene of scenes) {
      const dir = scene.director.toLowerCase();
      directorCounts[dir] = (directorCounts[dir] || 0) + 1;

      categoryCounts[scene.category] = (categoryCounts[scene.category] || 0) + 1;

      const hour = Math.floor(scene.timestamp / 3600);
      if (!hourlyBuckets[hour]) hourlyBuckets[hour] = [];
      hourlyBuckets[hour].push(scene);
    }

    const powerDirectors = Object.entries(directorCounts)
      .filter(([, count]) => count >= 3)
      .sort(([, a], [, b]) => b - a)
      .slice(0, 5);

    const peakHours = Object.entries(hourlyBuckets)
      .filter(([, group]) => group.length >= 5)
      .map(([hour, group]) => ({
        hour: Number(hour),
        count: group.length,
        dominantCategory: this.findDominant(group.map(g => g.category))
      }));

    return { powerDirectors, peakHours, categoryDistribution: categoryCounts };
  }

  findDominant(items) {
    const freq = {};
    items.forEach(i => { freq[i] = (freq[i] || 0) + 1; });
    return Object.entries(freq).sort(([, a], [, b]) => b - a)[0][0];
  }

  async produceEpisode(fromBlock, toBlock) {
    const sceneCount = await this.collectScenes(fromBlock, toBlock);
    if (sceneCount === 0) {
      return { status: "empty", message: "No scenes found in the specified block range." };
    }

    const narrative = await this.generateNarrativeSummary(this.sceneBuffer);
    const timeline = this.buildTimelineTree(this.sceneBuffer);
    const patterns = this.detectRecurringPatterns(this.sceneBuffer);

    const episode = {
      blockRange: { from: fromBlock, to: toBlock },
      totalScenes: sceneCount,
      narrativeSummary: narrative,
      timelineTree: timeline,
      patternAnalysis: patterns,
      generatedAt: new Date().toISOString()
    };

    await fs.writeFile(
      `episode_${fromBlock}_${toBlock}.json`,
      JSON.stringify(episode, null, 2)
    );

    return episode;
  }
}

async function main() {
  const engine = new NarrativeEngine(
    "https://rpc.ankr.com/eth",
    "0x0000000000000000000000000000000000001234",
    process.env.OPENAI_API_KEY
  );

  const latestBlock = await engine.provider.getBlockNumber();
  const episode = await engine.produceEpisode(latestBlock - 1000, latestBlock);

  console.log(`Episode produced: ${episode.totalScenes} scenes analyzed`);
  console.log(`Narrative title: ${episode.narrativeSummary.episodeTitle}`);
}

import json
import math
from datetime import datetime
from collections import defaultdict, Counter
from dataclasses import dataclass, field, asdict
from typing import Optional


@dataclass
class Transaction:
    tx_hash: str
    block_number: int
    timestamp: int
    from_address: str
    to_address: str
    value: float
    gas_used: int
    category: str
    intent: str
    context: str


@dataclass
class NarrativeBeat:
    phase: str
    start_index: int
    end_index: int
    transactions: list
    intensity: float
    description: str
    dominant_category: str
    key_addresses: list


@dataclass
class NarrativeArc:
    arc_id: str
    title: str
    beats: list = field(default_factory=list)
    arc_type: str = "Standard"
    total_duration_seconds: int = 0
    climax_intensity: float = 0.0
    resolution_quality: str = "Open-ended"
    genre: str = "Drama"


class NarrativeArcDetector:

    PHASES = ["Exposition", "RisingAction", "Climax", "FallingAction", "Resolution"]
    CLIMAX_KEYWORDS = ["liquidation", "flash_loan", "exploit", "governance_attack", "mass_transfer"]
    EXPOSITION_KEYWORDS = ["deploy", "approve", "init", "config", "oracle_update"]
    RESOLUTION_KEYWORDS = ["refund", "governance_proposal", "patch_deploy", "compensation"]

    def __init__(self, window_size: int = 50, intensity_threshold: float = 0.7):
        self.window_size = window_size
        self.intensity_threshold = intensity_threshold
        self.arc_counter = 0
        self.rolling_values = []
        self.value_momentum = []

    def compute_intensity(self, tx: Transaction) -> float:
        value_score = math.log1p(tx.value) / 20.0
        gas_score = math.log1p(tx.gas_used) / 30.0
        category_weight = 1.5 if any(kw in tx.category.lower() for kw in self.CLIMAX_KEYWORDS) else 1.0
        raw = (value_score * 0.4 + gas_score * 0.3 + 0.3) * category_weight
        return min(raw, 1.0)

    def compute_momentum(self, transactions: list) -> list:
        intensities = [self.compute_intensity(tx) for tx in transactions]
        momentum = [0.0] * len(intensities)
        for i in range(1, len(intensities)):
            window = intensities[max(0, i - 5):i + 1]
            momentum[i] = (window[-1] - window[0]) / len(window)
        return intensities, momentum

    def detect_climax(self, intensities: list) -> int:
        peak_idx = intensities.index(max(intensities))
        return peak_idx

    def segment_phases(self, intensities: list, climax_idx: int) -> dict:
        n = len(intensities)
        rising_end = climax_idx
        falling_start = climax_idx + 1

        exposition_end = 0
        for i in range(climax_idx):
            if intensities[i] > self.intensity_threshold * 0.3:
                exposition_end = i
                break
        else:
            exposition_end = max(1, climax_idx // 5)

        resolution_start = n
        for i in range(climax_idx + 1, n):
            if i < n - 1 and intensities[i] < 0.2:
                consecutive_low = 0
                for j in range(i, min(i + 5, n)):
                    if intensities[j] < 0.2:
                        consecutive_low += 1
                if consecutive_low >= 3:
                    resolution_start = i
                    break

        falling_end = min(resolution_start, n)

        return {
            "Exposition": (0, exposition_end),
            "RisingAction": (exposition_end, rising_end),
            "Climax": (climax_idx, climax_idx + 1),
            "FallingAction": (falling_start, falling_end),
            "Resolution": (resolution_start, n)
        }

    def classify_arc_type(self, intensities: list, climax_idx: int) -> str:
        n = len(intensities)
        if climax_idx < n * 0.2:
            return "ColdOpen"
        elif climax_idx > n * 0.8:
            return "SlowBurn"
        elif n - climax_idx > n * 0.5:
            return "Anti-Climax"
        else:
            return "Standard"

    def extract_key_addresses(self, transactions: list, phase_range: tuple) -> list:
        addr_counter = Counter()
        for tx in transactions[phase_range[0]:phase_range[1]]:
            addr_counter[tx.from_address] += 1
            addr_counter[tx.to_address] += 1
        return [addr for addr, _ in addr_counter.most_common(5)]

    def detect_arcs(self, transactions: list) -> list:
        if len(transactions) < 10:
            return []

        intensities, momentum = self.compute_momentum(transactions)
        climax_idx = self.detect_climax(intensities)
        phases = self.segment_phases(intensities, climax_idx)
        arc_type = self.classify_arc_type(intensities, climax_idx)

        self.arc_counter += 1
        arc = NarrativeArc(
            arc_id=f"ARC-{self.arc_counter:05d}",
            title=f"Chain Narrative Arc #{self.arc_counter}",
            arc_type=arc_type,
            total_duration_seconds=transactions[-1].timestamp - transactions[0].timestamp,
            climax_intensity=intensities[climax_idx],
            resolution_quality=self.assess_resolution(intensities, phases)
        )

        for phase_name, (start, end) in phases.items():
            if end <= start or start >= len(transactions):
                continue
            phase_txs = transactions[start:end]
            phase_intensities = intensities[start:end]
            key_addrs = self.extract_key_addresses(transactions, (start, end))
            dominant = self.find_dominant_category(phase_txs)

            beat = NarrativeBeat(
                phase=phase_name,
                start_index=start,
                end_index=end,
                transactions=[tx.tx_hash for tx in phase_txs],
                intensity=sum(phase_intensities) / len(phase_intensities) if phase_intensities else 0,
                description=self.generate_phase_description(phase_name, phase_txs),
                dominant_category=dominant,
                key_addresses=key_addrs
            )
            arc.beats.append(beat)

        return [arc]

    def assess_resolution(self, intensities: list, phases: dict) -> str:
        resolution_range = phases.get("Resolution", (len(intensities), len(intensities)))
        if resolution_range[0] >= len(intensities):
            return "Cliffhanger"
        resolution_intensities = intensities[resolution_range[0]:resolution_range[1]]
        if not resolution_intensities:
            return "Ambiguous"
        avg = sum(resolution_intensities) / len(resolution_intensities)
        if avg < 0.15:
            return "CleanResolution"
        elif avg < 0.4:
            return "PartialResolution"
        else:
            return "OngoingTension"

    def find_dominant_category(self, transactions: list) -> str:
        categories = [tx.category for tx in transactions]
        if not categories:
            return "Unknown"
        return Counter(categories).most_common(1)[0][0]

    def generate_phase_description(self, phase: str, txs: list) -> str:
        if not txs:
            return f"Empty {phase} phase"
        n = len(txs)
        avg_val = sum(t.value for t in txs) / n
        return f"{phase} phase with {n} transactions, average value {avg_val:.4f}"

    def export_arcs(self, arcs: list, filepath: str):
        output = []
        for arc in arcs:
            arc_dict = {
                "arc_id": arc.arc_id,
                "title": arc.title,
                "arc_type": arc.arc_type,
                "duration": arc.total_duration_seconds,
                "climax_intensity": round(arc.climax_intensity, 4),
                "resolution": arc.resolution_quality,
                "genre": arc.genre,
                "beats": [
                    {
                        "phase": b.phase,
                        "intensity": round(b.intensity, 4),
                        "tx_count": len(b.transactions),
                        "dominant_category": b.dominant_category,
                        "key_addresses": b.key_addresses
                    }
                    for b in arc.beats
                ]
            }
            output.append(arc_dict)
        with open(filepath, "w", encoding="utf-8") as f:
            json.dump(output, f, indent=2, ensure_ascii=False)


def load_transactions(filepath: str) -> list:
    with open(filepath, "r", encoding="utf-8") as f:
        raw = json.load(f)
    return [
        Transaction(
            tx_hash=tx["tx_hash"],
            block_number=tx["block_number"],
            timestamp=tx["timestamp"],
            from_address=tx["from_address"],
            to_address=tx["to_address"],
            value=float(tx["value"]),
            gas_used=int(tx["gas_used"]),
            category=tx["category"],
            intent=tx.get("intent", ""),
            context=tx.get("context", "")
        )
        for tx in raw
    ]


if __name__ == "__main__":
    transactions = load_transactions("onchain_events.json")
    detector = NarrativeArcDetector(window_size=50, intensity_threshold=0.6)
    detected_arcs = detector.detect_arcs(transactions)
    detector.export_arcs(detected_arcs, "narrative_arcs_output.json")

    for arc in detected_arcs:
        print(f"Arc: {arc.arc_id} | Type: {arc.arc_type}")
        for beat in arc.beats:
            print(f"  {beat.phase}: intensity={beat.intensity:.3f}, txs={len(beat.transactions)}, category={beat.dominant_category}")