"""
Standalone mock E2E test: seeds videos, runs worker, verifies results.
Run: python -m tests.run_mock_e2e
"""
import asyncio
import logging
import sys
import os

os.environ["MOCK_MODE"] = "true"

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.config import EnvConfig
from src.db import MockDB, VideoTask, WorkerStats
from src.r2_client import R2Client
from src.providers.aistudio import AIStudioProvider
from src.providers.openrouter import OpenRouterProvider
from src.pipeline import Pipeline

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
logger = logging.getLogger("mock_e2e")


async def run():
    config = EnvConfig(mock_mode=True, worker_id="e2e-test-worker")

    # Initialize components
    db = MockDB()
    r2 = R2Client(config)
    primary = AIStudioProvider(api_key="fake", mock_mode=True)
    fallback = OpenRouterProvider(api_key="fake", mock_mode=True)
    stats = WorkerStats()

    # Seed 3 mock videos across different languages
    videos = [
        VideoTask(video_id="mock_telugu_001", language="te", segment_count=5),
        VideoTask(video_id="mock_hindi_002", language="hi", segment_count=5),
        VideoTask(video_id="mock_english_003", language="en", segment_count=5),
    ]
    db.seed_videos(videos)
    logger.info(f"Seeded {len(videos)} mock videos")

    # Register worker
    await db.register_worker("e2e-test-worker", "aistudio", "mock-gpu", {"test": True})

    pipeline = Pipeline(
        config=config, db=db, r2=r2,
        primary_provider=primary, fallback_provider=fallback,
        worker_id="e2e-test-worker", stats=stats,
    )

    # Process all videos
    processed = 0
    while True:
        task = await db.claim_video("e2e-test-worker")
        if task is None:
            break
        logger.info(f"\n{'='*60}")
        logger.info(f"Processing video: {task.video_id} (lang={task.language})")
        logger.info(f"{'='*60}")
        success = await pipeline.process_video(task)
        if success:
            processed += 1
        logger.info(f"Video {task.video_id}: {'SUCCESS' if success else 'FAILED'}")

    # Report results
    logger.info(f"\n{'='*60}")
    logger.info("=== E2E TEST SUMMARY ===")
    logger.info(f"{'='*60}")
    logger.info(f"Videos processed: {processed}/{len(videos)}")
    logger.info(f"Total segments sent: {stats.segments_sent}")
    logger.info(f"Total segments completed: {stats.segments_completed}")
    logger.info(f"Total segments failed: {stats.segments_failed}")
    logger.info(f"Total 429s: {stats.segments_429}")
    logger.info(f"Total cache hits: {stats.cache_hits}")
    logger.info(f"Total batches: {stats.batches_completed}")
    logger.info(f"DB results count: {len(db.results)}")
    logger.info(f"DB flags count: {len(db.flags)}")

    # Validate DB state
    all_done = all(v.status == "done" for v in db.video_queue)
    logger.info(f"All videos marked done: {all_done}")

    # Check result quality
    if db.results:
        quality_scores = [r.get("quality_score", 0) for r in db.results]
        avg_quality = sum(quality_scores) / len(quality_scores)
        logger.info(f"Average quality score: {avg_quality:.3f}")
        logger.info(f"Sample result keys: {list(db.results[0].keys())}")

    # Assertions
    assert processed == len(videos), f"Expected {len(videos)} processed, got {processed}"
    assert all_done, "Not all videos marked done"
    assert stats.segments_completed > 0, "No segments completed"
    assert len(db.results) > 0, "No results in DB"

    logger.info("\n*** ALL E2E CHECKS PASSED ***")


if __name__ == "__main__":
    asyncio.run(run())