engine/speed_powered_engine.py

"""
SPEED-POWERED NARRATION ENGINE
Leverages 2249x speed advantage for real-time frame analysis
"""
import json
import time
import subprocess
from collections import deque

class SpeedPoweredEngine:
    def __init__(self, video_path):
        self.video_path = video_path
        self.scene_duration = self.get_video_duration()
        self.frame_analysis_cache = {}
        self.visual_context_buffer = deque(maxlen=10)  # Last 10 frames
        
    def get_video_duration(self):
        """Get actual video duration"""
        cmd = [
            'ffprobe', '-i', self.video_path,
            '-show_entries', 'format=duration',
            '-v', 'quiet', '-of', 'csv=p=0'
        ]
        result = subprocess.run(cmd, capture_output=True, text=True)
        return float(result.stdout.strip()) if result.returncode == 0 else 600
    
    def simulate_frame_analysis(self, timestamp):
        """
        SIMULATE our 2.5ms frame analysis capability
        In production, this would use our actual VLM for real-time analysis
        """
        # Mock frame analysis - in reality, this would be our VLM processing frames
        frame_contexts = {
            5: {"scene": "forest_establishing", "characters": ["rangers"], "action": "riding", "mood": "apprehensive"},
            25: {"scene": "character_focus", "characters": ["royce"], "action": "leading", "mood": "arrogant"},
            40: {"scene": "group_dynamics", "characters": ["will", "gared"], "action": "exchanging_glances", "mood": "worried"},
            75: {"scene": "discovery", "characters": ["will"], "action": "discovering_bodies", "mood": "horrified", "critical_visual": True},
            95: {"scene": "investigation", "characters": ["all"], "action": "examining_patterns", "mood": "terrified", "critical_visual": True},
            150: {"scene": "approach", "characters": ["white_walker"], "action": "emerging", "mood": "terrified", "supernatural": True},
            165: {"scene": "reveal", "characters": ["white_walker"], "action": "revealing", "mood": "awe", "supernatural": True, "critical_visual": True},
            190: {"scene": "combat", "characters": ["royce", "white_walker"], "action": "fighting", "mood": "intense"},
            250: {"scene": "death", "characters": ["royce"], "action": "dying", "mood": "tragic"},
            280: {"scene": "brutality", "characters": ["gared"], "action": "executed", "mood": "brutal"},
            310: {"scene": "escape", "characters": ["will"], "action": "fleeing", "mood": "panicked"}
        }
        
        return frame_contexts.get(timestamp, {"scene": "unknown", "characters": [], "action": "unknown", "mood": "neutral"})
    
    def analyze_visual_progression(self, current_time):
        """
        Use speed advantage to analyze visual progression in real-time
        Returns whether this is the OPTIMAL moment for revelation
        """
        # Simulate analyzing multiple frames around current time
        analysis_window = [current_time - 2, current_time - 1, current_time, current_time + 1, current_time + 2]
        frame_analyses = []
        
        for frame_time in analysis_window:
            if frame_time >= 0:
                analysis = self.simulate_frame_analysis(frame_time)
                frame_analyses.append(analysis)
                self.visual_context_buffer.append(analysis)
        
        # Use frame progression to determine optimal timing
        current_frame = self.simulate_frame_analysis(current_time)
        
        # Check if this is the FIRST clear visual of something important
        is_first_clear_view = self.is_first_clear_visual(current_frame, frame_analyses)
        
        # Check visual progression for spoiler protection
        should_reveal = self.should_reveal_based_on_progression(current_frame, frame_analyses)
        
        return {
            'optimal_timing': is_first_clear_view and should_reveal,
            'visual_clarity': self.assess_visual_clarity(current_frame),
            'progression_context': self.get_progression_context(frame_analyses),
            'first_clear_view': is_first_clear_view
        }
    
    def is_first_clear_visual(self, current_frame, frame_analyses):
        """
        Use frame progression to determine if this is the FIRST clear visual
        of something important (not a spoiler)
        """
        current_has_supernatural = current_frame.get('supernatural', False)
        current_critical = current_frame.get('critical_visual', False)
        
        if not (current_has_supernatural or current_critical):
            return False
        
        # Check previous frames - was this visible but unclear before?
        previous_frames = frame_analyses[:-1]  # All frames before current
        was_previously_visible = any(
            frame.get('supernatural', False) or frame.get('critical_visual', False)
            for frame in previous_frames
        )
        
        # This is the first clear visual if it's important AND wasn't clearly visible before
        return not was_previously_visible
    
    def should_reveal_based_on_progression(self, current_frame, frame_analyses):
        """
        Use visual progression to decide when to reveal information
        """
        current_action = current_frame.get('action', '')
        current_mood = current_frame.get('mood', '')
        
        # Don't reveal supernatural elements during setup phases
        if current_frame.get('supernatural', False):
            # Check if we're in a revelation-appropriate part of the scene
            setup_actions = ['riding', 'leading', 'exchanging_glances']
            if current_action in setup_actions:
                return False
            
            # Check mood progression - reveal when tension peaks
            if current_mood in ['terrified', 'awe']:
                return True
        
        # Always reveal critical visual information
        if current_frame.get('critical_visual', False):
            return True
        
        return True
    
    def assess_visual_clarity(self, frame_analysis):
        """Assess how clear and unambiguous the visual information is"""
        action = frame_analysis.get('action', '')
        characters = frame_analysis.get('characters', [])
        
        clarity_score = 0
        
        # Specific actions are clearer
        clear_actions = ['discovering_bodies', 'revealing', 'dying', 'fleeing']
        ambiguous_actions = ['emerging', 'examining_patterns']
        
        if action in clear_actions:
            clarity_score += 2
        elif action in ambiguous_actions:
            clarity_score += 1
        
        # Specific characters are clearer
        if 'white_walker' in characters:
            clarity_score += 2
        elif len(characters) == 1:  # Single character focus is clearer
            clarity_score += 1
        
        return clarity_score >= 2  # Only narrate when visual is clear
    
    def get_progression_context(self, frame_analyses):
        """Get context from frame progression"""
        if len(frame_analyses) < 2:
            return "no_progression"
        
        previous_mood = frame_analyses[-2].get('mood', 'neutral')
        current_mood = frame_analyses[-1].get('mood', 'neutral')
        
        if previous_mood != current_mood:
            return f"mood_shift_{previous_mood}_to_{current_mood}"
        
        return "stable_progression"
    
    def generate_speed_optimized_narration(self, timestamp, audio_context):
        """
        Generate narration using speed-powered frame analysis
        """
        # Analyze visual progression in real-time (simulated)
        progression_analysis = self.analyze_visual_progression(timestamp)
        frame_analysis = self.simulate_frame_analysis(timestamp)
        
        # Only narrate if timing is optimal and visual is clear
        if not (progression_analysis['optimal_timing'] and progression_analysis['visual_clarity']):
            return {'decision': 'silence', 'reason': 'non_optimal_timing_or_unclear_visual'}
        
        # Generate context-appropriate narration
        narration = self.context_aware_narration(frame_analysis, progression_analysis)
        
        return {
            'decision': 'narrate',
            'text': narration,
            'reason': f"first_clear_visual_{progression_analysis['progression_context']}",
            'frame_analysis': frame_analysis
        }
    
    def context_aware_narration(self, frame_analysis, progression_analysis):
        """Generate narration based on visual context and progression"""
        action = frame_analysis.get('action', '')
        characters = frame_analysis.get('characters', [])
        mood = frame_analysis.get('mood', '')
        
        narration_templates = {
            'discovering_bodies': "Will discovers dismembered wildling bodies arranged in a ritualistic circle",
            'examining_patterns': "Limbs and torsos carefully positioned in grotesque patterns defying natural explanation",
            'revealing': "The White Walker reveals its crystalline armor and glowing blue eyes - ancient power made flesh",
            'emerging': "A pale figure emerges from the mist, moving with unnatural grace",
            'dying': "Royce falls, his blood staining the pristine snow crimson",
            'executed': "Gared meets a swift, brutal end at the Walker's hand",
            'fleeing': "Will scrambles backward through the snow, heart hammering in terror"
        }
        
        # Use progression context to adjust narration
        if progression_analysis['progression_context'].startswith('mood_shift'):
            # Add emotional context for mood shifts
            base_narration = narration_templates.get(action, "Significant visual moment")
            return f"{base_narration} - the mood shifts to {mood}"
        
        return narration_templates.get(action, "Important visual development")

if __name__ == "__main__":
    # Test the speed-powered engine
    engine = SpeedPoweredEngine('gameofthronesseason1episode1.mp4')
    
    print("🚀 SPEED-POWERED FRAME ANALYSIS TEST")
    print("💡 Using 2249x speed advantage for real-time visual understanding")
    print(f"📊 Scene Duration: {engine.scene_duration:.1f}s\n")
    
    # Test critical moments with frame progression awareness
    test_moments = [75, 95, 150, 165, 190]
    
    for moment in test_moments:
        print(f"🎯 Analyzing moment {moment}s:")
        progression = engine.analyze_visual_progression(moment)
        decision = engine.generate_speed_optimized_narration(moment, {})
        
        print(f"   Frame Analysis: {engine.simulate_frame_analysis(moment)}")
        print(f"   Progression: {progression}")
        print(f"   Decision: {decision['decision']} - {decision.get('reason', '')}")
        if decision['decision'] == 'narrate':
            print(f"   Narration: {decision['text']}")
        print()