#!/usr/bin/env python3
"""
Process meeting recordings to extract audio + screen content.
Combines Whisper transcripts with OCR from screen shares.
"""
import argparse
from pathlib import Path
import sys
import json
import logging
import subprocess
import shutil

from meetus.frame_extractor import FrameExtractor
from meetus.ocr_processor import OCRProcessor
from meetus.transcript_merger import TranscriptMerger

logger = logging.getLogger(__name__)


def setup_logging(verbose: bool = False):
    """
    Configure logging for the application.

    Args:
        verbose: If True, set DEBUG level, otherwise INFO
    """
    level = logging.DEBUG if verbose else logging.INFO

    # Configure root logger
    logging.basicConfig(
        level=level,
        format='%(asctime)s - %(levelname)s - %(message)s',
        datefmt='%H:%M:%S'
    )

    # Suppress verbose output from libraries
    logging.getLogger('PIL').setLevel(logging.WARNING)
    logging.getLogger('easyocr').setLevel(logging.WARNING)
    logging.getLogger('paddleocr').setLevel(logging.WARNING)


def run_whisper(video_path: Path, model: str = "base", output_dir: str = "output") -> Path:
    """
    Run Whisper transcription on video file.

    Args:
        video_path: Path to video file
        model: Whisper model to use (tiny, base, small, medium, large)
        output_dir: Directory to save output

    Returns:
        Path to generated JSON transcript
    """
    # Check if whisper is installed
    if not shutil.which("whisper"):
        logger.error("Whisper is not installed. Install it with: pip install openai-whisper")
        sys.exit(1)

    logger.info(f"Running Whisper transcription (model: {model})...")
    logger.info("This may take a few minutes depending on video length...")

    # Run whisper command
    cmd = [
        "whisper",
        str(video_path),
        "--model", model,
        "--output_format", "json",
        "--output_dir", output_dir
    ]

    try:
        result = subprocess.run(
            cmd,
            check=True,
            capture_output=True,
            text=True
        )

        # Whisper outputs to <output_dir>/<video_stem>.json
        transcript_path = Path(output_dir) / f"{video_path.stem}.json"

        if transcript_path.exists():
            logger.info(f"✓ Whisper transcription completed: {transcript_path}")
            return transcript_path
        else:
            logger.error("Whisper completed but transcript file not found")
            sys.exit(1)

    except subprocess.CalledProcessError as e:
        logger.error(f"Whisper failed: {e.stderr}")
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(
        description="Extract screen content from meeting recordings and merge with transcripts",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  # Run Whisper + full processing in one command
  python process_meeting.py samples/meeting.mkv --run-whisper

  # Process video with existing Whisper transcript
  python process_meeting.py samples/meeting.mkv --transcript output/meeting.json

  # Use scene detection instead of interval
  python process_meeting.py samples/meeting.mkv --run-whisper --scene-detection

  # Use different Whisper model and OCR engine
  python process_meeting.py samples/meeting.mkv --run-whisper --whisper-model small --ocr-engine easyocr

  # Extract frames only (no transcript)
  python process_meeting.py samples/meeting.mkv --extract-only
        """
    )

    parser.add_argument(
        'video',
        help='Path to video file'
    )

    parser.add_argument(
        '--transcript', '-t',
        help='Path to Whisper transcript (JSON or TXT)',
        default=None
    )

    parser.add_argument(
        '--run-whisper',
        action='store_true',
        help='Run Whisper transcription before processing'
    )

    parser.add_argument(
        '--whisper-model',
        choices=['tiny', 'base', 'small', 'medium', 'large'],
        help='Whisper model to use (default: base)',
        default='base'
    )

    parser.add_argument(
        '--output', '-o',
        help='Output file for enhanced transcript (default: output/<video>_enhanced.txt)',
        default=None
    )

    parser.add_argument(
        '--output-dir',
        help='Directory for output files (default: output/)',
        default='output'
    )

    parser.add_argument(
        '--frames-dir',
        help='Directory to save extracted frames (default: frames/)',
        default='frames'
    )

    parser.add_argument(
        '--interval',
        type=int,
        help='Extract frame every N seconds (default: 5)',
        default=5
    )

    parser.add_argument(
        '--scene-detection',
        action='store_true',
        help='Use scene detection instead of interval extraction'
    )

    parser.add_argument(
        '--ocr-engine',
        choices=['tesseract', 'easyocr', 'paddleocr'],
        help='OCR engine to use (default: tesseract)',
        default='tesseract'
    )

    parser.add_argument(
        '--no-deduplicate',
        action='store_true',
        help='Disable text deduplication'
    )

    parser.add_argument(
        '--extract-only',
        action='store_true',
        help='Only extract frames and OCR, skip transcript merging'
    )

    parser.add_argument(
        '--format',
        choices=['detailed', 'compact'],
        help='Output format style (default: detailed)',
        default='detailed'
    )

    parser.add_argument(
        '--verbose', '-v',
        action='store_true',
        help='Enable verbose logging (DEBUG level)'
    )

    args = parser.parse_args()

    # Setup logging
    setup_logging(args.verbose)

    # Validate video path
    video_path = Path(args.video)
    if not video_path.exists():
        logger.error(f"Video file not found: {args.video}")
        sys.exit(1)

    # Create output directory
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    # Set default output path
    if args.output is None:
        args.output = str(output_dir / f"{video_path.stem}_enhanced.txt")

    # Run Whisper if requested
    if args.run_whisper:
        logger.info("=" * 80)
        logger.info("STEP 0: Running Whisper Transcription")
        logger.info("=" * 80)
        transcript_path = run_whisper(video_path, args.whisper_model, str(output_dir))
        args.transcript = str(transcript_path)
        logger.info("")

    logger.info("=" * 80)
    logger.info("MEETING PROCESSOR")
    logger.info("=" * 80)
    logger.info(f"Video: {video_path.name}")
    logger.info(f"OCR Engine: {args.ocr_engine}")
    logger.info(f"Frame extraction: {'Scene detection' if args.scene_detection else f'Every {args.interval}s'}")
    if args.transcript:
        logger.info(f"Transcript: {args.transcript}")
    logger.info("=" * 80)

    # Step 1: Extract frames
    logger.info("Step 1: Extracting frames from video...")
    extractor = FrameExtractor(str(video_path), args.frames_dir)

    if args.scene_detection:
        frames_info = extractor.extract_scene_changes()
    else:
        frames_info = extractor.extract_by_interval(args.interval)

    if not frames_info:
        logger.error("No frames extracted")
        sys.exit(1)

    logger.info(f"✓ Extracted {len(frames_info)} frames")

    # Step 2: Run OCR on frames
    logger.info("Step 2: Running OCR on extracted frames...")
    try:
        ocr = OCRProcessor(engine=args.ocr_engine)
        screen_segments = ocr.process_frames(
            frames_info,
            deduplicate=not args.no_deduplicate
        )
        logger.info(f"✓ Processed {len(screen_segments)} frames with text content")

    except ImportError as e:
        logger.error(f"{e}")
        logger.error(f"To install {args.ocr_engine}:")
        logger.error(f"  pip install {args.ocr_engine}")
        sys.exit(1)

    # Save OCR results as JSON
    ocr_output = output_dir / f"{video_path.stem}_ocr.json"
    with open(ocr_output, 'w', encoding='utf-8') as f:
        json.dump(screen_segments, f, indent=2, ensure_ascii=False)
    logger.info(f"✓ Saved OCR results to: {ocr_output}")

    if args.extract_only:
        logger.info("Done! (extract-only mode)")
        return

    # Step 3: Merge with transcript (if provided)
    merger = TranscriptMerger()

    if args.transcript:
        logger.info("Step 3: Merging with Whisper transcript...")
        transcript_path = Path(args.transcript)

        if not transcript_path.exists():
            logger.warning(f"Transcript not found: {args.transcript}")
            logger.info("Proceeding with screen content only...")
            audio_segments = []
        else:
            audio_segments = merger.load_whisper_transcript(str(transcript_path))
            logger.info(f"✓ Loaded {len(audio_segments)} audio segments")
    else:
        logger.info("No transcript provided, using screen content only...")
        audio_segments = []

    # Merge and format
    merged = merger.merge_transcripts(audio_segments, screen_segments)
    formatted = merger.format_for_claude(merged, format_style=args.format)

    # Save output
    merger.save_transcript(formatted, args.output)

    logger.info("=" * 80)
    logger.info("✓ PROCESSING COMPLETE!")
    logger.info("=" * 80)
    logger.info(f"Enhanced transcript: {args.output}")
    logger.info(f"OCR data: {ocr_output}")
    logger.info(f"Frames: {args.frames_dir}/")
    logger.info("")
    logger.info("You can now use the enhanced transcript with Claude for summarization!")


if __name__ == '__main__':
    main()