#!/usr/bin/env python3
"""
Example script showing conversion with GPU monitoring.
"""

import subprocess
import sys
import time
from pathlib import Path

# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent.parent))

from loguru import logger

from src.docling_converter import PDFConverter
from src.docling_converter.utils import analyze_gpu_metrics, setup_logging, suppress_library_logging


def convert_with_monitoring(pdf_path: Path, output_dir: Path, workers: int = 2):
    """
    Convert PDF while monitoring GPU usage.

    Args:
        pdf_path: Path to PDF file
        output_dir: Output directory
        workers: Number of workers
    """
    # Setup logging
    setup_logging(verbose=False)
    suppress_library_logging()

    # Start GPU monitoring
    metrics_file = Path(f"gpu_metrics_{pdf_path.stem}.log")
    monitor_script = Path(__file__).parent.parent / "tools" / "monitor_gpu.sh"

    logger.info("Starting GPU monitoring...")
    monitor_process = subprocess.Popen(
        [str(monitor_script), str(metrics_file)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
    )

    # Give monitor time to start
    time.sleep(2)

    try:
        # Initialize converter
        logger.info(f"Converting {pdf_path.name} with {workers} workers")
        converter = PDFConverter(output_dir=str(output_dir), max_workers=workers)

        # Record start time
        start_time = time.time()

        # Perform conversion
        results = converter.convert(pdf_path)

        # Record end time
        duration = time.time() - start_time

        # Report results
        logger.success(f"Conversion complete in {duration:.1f} seconds")
        logger.info(f"Pages converted: {results['success']}")
        if results["failed"] > 0:
            logger.warning(f"Pages failed: {results['failed']}")

    finally:
        # Stop monitoring
        logger.info("Stopping GPU monitoring...")
        monitor_process.terminate()
        monitor_process.wait()

    # Analyze GPU metrics
    if metrics_file.exists():
        logger.info("\nGPU Performance Metrics:")
        logger.info("-" * 30)

        avg_gpu, peak_gpu, avg_memory = analyze_gpu_metrics(metrics_file)

        logger.info(f"Average GPU usage: {avg_gpu:.1f}%")
        logger.info(f"Peak GPU usage: {peak_gpu:.1f}%")
        logger.info(f"Average memory usage: {avg_memory:.1f}%")

        # Performance efficiency
        if duration > 0:
            pages_per_second = results["success"] / duration
            logger.info(f"Processing rate: {pages_per_second:.2f} pages/second")

    return results


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Convert PDF with GPU monitoring")
    parser.add_argument("pdf_path", help="Path to PDF file")
    parser.add_argument("--output-dir", "-o", default="output", help="Output directory (default: output)")
    parser.add_argument("--workers", "-w", type=int, default=2, help="Number of workers (default: 2)")

    args = parser.parse_args()

    pdf_path = Path(args.pdf_path)
    if not pdf_path.exists():
        logger.error(f"PDF not found: {pdf_path}")
        sys.exit(1)

    output_dir = Path(args.output_dir)

    convert_with_monitoring(pdf_path, output_dir, args.workers)