validate_complete_system.py

#!/usr/bin/env python3
"""
Complete System Validation Script for Video Processor v0.4.0

This script validates that all four phases of the video processor are working correctly:
- Phase 1: AI-Powered Content Analysis
- Phase 2: Next-Generation Codecs & HDR
- Phase 3: Adaptive Streaming
- Phase 4: Complete 360° Video Processing

Run this to verify the complete system is operational.
"""

import asyncio
import logging
from pathlib import Path

# Configure logging
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)


async def validate_system():
    """Comprehensive system validation."""
    print("🎬 Video Processor v0.4.0 - Complete System Validation")
    print("=" * 60)

    validation_results = {
        "phase_1_ai": False,
        "phase_2_codecs": False,
        "phase_3_streaming": False,
        "phase_4_360": False,
        "core_processor": False,
        "configuration": False,
    }

    # Test Configuration System
    print("\n📋 Testing Configuration System...")
    try:
        from video_processor.config import ProcessorConfig

        config = ProcessorConfig(
            quality_preset="high",
            enable_ai_analysis=True,
            enable_av1_encoding=False,  # Don't require system codecs
            enable_hevc_encoding=False,
            # Don't enable 360° processing in basic config test
            output_formats=["mp4"],
        )

        assert hasattr(config, "enable_ai_analysis")
        assert hasattr(config, "enable_360_processing")
        assert config.quality_preset == "high"

        validation_results["configuration"] = True
        print("✅ Configuration System: OPERATIONAL")

    except Exception as e:
        print(f"❌ Configuration System: FAILED - {e}")
        return validation_results

    # Test Phase 1: AI Analysis
    print("\n🤖 Testing Phase 1: AI-Powered Content Analysis...")
    try:
        from video_processor.ai import VideoContentAnalyzer
        from video_processor.ai.content_analyzer import (
            ContentAnalysis,
            SceneAnalysis,
            QualityMetrics,
        )

        analyzer = VideoContentAnalyzer()

        # Test model creation
        scene_analysis = SceneAnalysis(
            scene_boundaries=[0.0, 30.0, 60.0],
            scene_count=3,
            average_scene_length=30.0,
            key_moments=[5.0, 35.0, 55.0],
            confidence_scores=[0.9, 0.8, 0.85],
        )

        quality_metrics = QualityMetrics(
            sharpness_score=0.8,
            brightness_score=0.6,
            contrast_score=0.7,
            noise_level=0.2,
            overall_quality=0.75,
        )

        content_analysis = ContentAnalysis(
            scenes=scene_analysis,
            quality_metrics=quality_metrics,
            duration=90.0,
            resolution=(1920, 1080),
            has_motion=True,
            motion_intensity=0.6,
            is_360_video=False,
            recommended_thumbnails=[5.0, 35.0, 55.0],
        )

        assert content_analysis.scenes.scene_count == 3
        assert content_analysis.quality_metrics.overall_quality == 0.75
        assert len(content_analysis.recommended_thumbnails) == 3

        validation_results["phase_1_ai"] = True
        print("✅ Phase 1 - AI Content Analysis: OPERATIONAL")

    except Exception as e:
        print(f"❌ Phase 1 - AI Content Analysis: FAILED - {e}")

    # Test Phase 2: Advanced Codecs
    print("\n🎥 Testing Phase 2: Next-Generation Codecs...")
    try:
        from video_processor.core.advanced_encoders import AdvancedVideoEncoder
        from video_processor.core.enhanced_processor import EnhancedVideoProcessor

        # Test advanced encoder
        advanced_encoder = AdvancedVideoEncoder(config)

        # Verify methods exist
        assert hasattr(advanced_encoder, "encode_av1")
        assert hasattr(advanced_encoder, "encode_hevc")
        assert hasattr(advanced_encoder, "get_supported_advanced_codecs")

        # Test supported codecs
        supported_codecs = advanced_encoder.get_supported_advanced_codecs()
        av1_bitrate_multiplier = advanced_encoder.get_av1_bitrate_multiplier()

        print(f"   Supported Advanced Codecs: {supported_codecs}")
        print(f"   AV1 Bitrate Multiplier: {av1_bitrate_multiplier}")
        print(f"   AV1 Encoding Available: {'encode_av1' in dir(advanced_encoder)}")
        print(f"   HEVC Encoding Available: {'encode_hevc' in dir(advanced_encoder)}")

        # Test enhanced processor
        enhanced_processor = EnhancedVideoProcessor(config)
        assert hasattr(enhanced_processor, "content_analyzer")
        assert hasattr(enhanced_processor, "process_video_enhanced")

        validation_results["phase_2_codecs"] = True
        print("✅ Phase 2 - Advanced Codecs: OPERATIONAL")

    except Exception as e:
        import traceback

        print(f"❌ Phase 2 - Advanced Codecs: FAILED - {e}")
        print(f"   Debug info: {traceback.format_exc()}")

    # Test Phase 3: Adaptive Streaming
    print("\n📡 Testing Phase 3: Adaptive Streaming...")
    try:
        from video_processor.streaming import AdaptiveStreamProcessor
        from video_processor.streaming.hls import HLSGenerator
        from video_processor.streaming.dash import DASHGenerator

        stream_processor = AdaptiveStreamProcessor(config)
        hls_generator = HLSGenerator()
        dash_generator = DASHGenerator()

        assert hasattr(stream_processor, "create_adaptive_stream")
        assert hasattr(hls_generator, "create_master_playlist")
        assert hasattr(dash_generator, "create_manifest")

        validation_results["phase_3_streaming"] = True
        print("✅ Phase 3 - Adaptive Streaming: OPERATIONAL")

    except Exception as e:
        print(f"❌ Phase 3 - Adaptive Streaming: FAILED - {e}")

    # Test Phase 4: 360° Video Processing
    print("\n🌐 Testing Phase 4: Complete 360° Video Processing...")
    try:
        from video_processor.video_360 import (
            Video360Processor,
            Video360StreamProcessor,
            ProjectionConverter,
            SpatialAudioProcessor,
        )
        from video_processor.video_360.models import (
            ProjectionType,
            StereoMode,
            SpatialAudioType,
            SphericalMetadata,
            ViewportConfig,
            Video360Quality,
            Video360Analysis,
        )

        # Test 360° processors
        video_360_processor = Video360Processor(config)
        stream_360_processor = Video360StreamProcessor(config)
        projection_converter = ProjectionConverter()
        spatial_processor = SpatialAudioProcessor()

        # Test 360° models
        metadata = SphericalMetadata(
            is_spherical=True,
            projection=ProjectionType.EQUIRECTANGULAR,
            stereo_mode=StereoMode.MONO,
            width=3840,
            height=1920,
            has_spatial_audio=True,
            audio_type=SpatialAudioType.AMBISONIC_BFORMAT,
        )

        viewport = ViewportConfig(yaw=0.0, pitch=0.0, fov=90.0, width=1920, height=1080)

        quality = Video360Quality()

        analysis = Video360Analysis(metadata=metadata, quality=quality)

        # Validate all components
        assert hasattr(video_360_processor, "analyze_360_content")
        assert hasattr(projection_converter, "convert_projection")
        assert hasattr(spatial_processor, "convert_to_binaural")
        assert hasattr(stream_360_processor, "create_360_adaptive_stream")

        assert metadata.is_spherical
        assert metadata.projection == ProjectionType.EQUIRECTANGULAR
        assert viewport.width == 1920
        assert quality.overall_quality >= 0.0
        assert analysis.metadata.is_spherical

        # Test enum completeness
        projections = [
            ProjectionType.EQUIRECTANGULAR,
            ProjectionType.CUBEMAP,
            ProjectionType.EAC,
            ProjectionType.FISHEYE,
            ProjectionType.STEREOGRAPHIC,
            ProjectionType.FLAT,
        ]

        for proj in projections:
            assert proj.value is not None

        validation_results["phase_4_360"] = True
        print("✅ Phase 4 - 360° Video Processing: OPERATIONAL")

    except Exception as e:
        print(f"❌ Phase 4 - 360° Video Processing: FAILED - {e}")

    # Test Core Processor Integration
    print("\n⚡ Testing Core Video Processor Integration...")
    try:
        from video_processor import VideoProcessor

        processor = VideoProcessor(config)

        assert hasattr(processor, "process_video")
        assert hasattr(processor, "config")
        assert processor.config.enable_ai_analysis == True

        validation_results["core_processor"] = True
        print("✅ Core Video Processor: OPERATIONAL")

    except Exception as e:
        print(f"❌ Core Video Processor: FAILED - {e}")

    # Summary
    print("\n" + "=" * 60)
    print("🎯 VALIDATION SUMMARY")
    print("=" * 60)

    total_tests = len(validation_results)
    passed_tests = sum(validation_results.values())

    for component, status in validation_results.items():
        status_icon = "✅" if status else "❌"
        component_name = component.replace("_", " ").title()
        print(f"{status_icon} {component_name}")

    print(f"\nOverall Status: {passed_tests}/{total_tests} components operational")

    if passed_tests == total_tests:
        print("\n🎉 ALL SYSTEMS OPERATIONAL!")
        print("🚀 Video Processor v0.4.0 is ready for production use!")
        print("\n🎬 Complete multimedia processing platform with:")
        print("   • AI-powered content analysis")
        print("   • Next-generation codecs (AV1, HEVC, HDR)")
        print("   • Adaptive streaming (HLS, DASH)")
        print("   • Complete 360° video processing")
        print("   • Production-ready deployment")

        return True
    else:
        failed_components = [k for k, v in validation_results.items() if not v]
        print(f"\n⚠️ ISSUES DETECTED:")
        for component in failed_components:
            print(f"   • {component.replace('_', ' ').title()}")

        return False


if __name__ == "__main__":
    """Run system validation."""
    print("Starting Video Processor v0.4.0 validation...")

    try:
        success = asyncio.run(validate_system())
        exit_code = 0 if success else 1

        print(f"\nValidation {'PASSED' if success else 'FAILED'}")
        exit(exit_code)

    except Exception as e:
        print(f"\n❌ VALIDATION ERROR: {e}")
        print("Please check your installation and dependencies.")
        exit(1)