#!/usr/bin/env python3
"""
Comprehensive test runner for deb-mock
"""

import os
import sys
import subprocess
import argparse
import time
from pathlib import Path


def run_command(cmd, description, check=True):
    """Run a command and handle errors"""
    print(f"\n🔄 {description}...")
    print(f"Command: {' '.join(cmd)}")
    
    start_time = time.time()
    try:
        result = subprocess.run(cmd, check=check, capture_output=True, text=True)
        duration = time.time() - start_time
        
        if result.returncode == 0:
            print(f"✅ {description} completed successfully in {duration:.2f}s")
            if result.stdout:
                print("Output:", result.stdout)
        else:
            print(f"❌ {description} failed with return code {result.returncode}")
            if result.stderr:
                print("Error:", result.stderr)
            if result.stdout:
                print("Output:", result.stdout)
        
        return result
    except subprocess.CalledProcessError as e:
        duration = time.time() - start_time
        print(f"❌ {description} failed with exception in {duration:.2f}s")
        print(f"Error: {e}")
        if e.stdout:
            print("Output:", e.stdout)
        if e.stderr:
            print("Error:", e.stderr)
        return e


def install_test_dependencies():
    """Install test dependencies"""
    cmd = [sys.executable, "-m", "pip", "install", "-r", "tests/requirements.txt"]
    return run_command(cmd, "Installing test dependencies")


def run_unit_tests(parallel=False, coverage=True, verbose=False):
    """Run unit tests"""
    cmd = [sys.executable, "-m", "pytest"]
    
    if parallel:
        cmd.extend(["-n", "auto"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing"])
    
    if verbose:
        cmd.extend(["-v", "-s"])
    
    cmd.append("tests/")
    
    return run_command(cmd, "Running unit tests")


def run_integration_tests(parallel=False, coverage=True, verbose=False):
    """Run integration tests"""
    cmd = [sys.executable, "-m", "pytest", "-m", "integration"]
    
    if parallel:
        cmd.extend(["-n", "auto"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing"])
    
    if verbose:
        cmd.extend(["-v", "-s"])
    
    cmd.append("tests/")
    
    return run_command(cmd, "Running integration tests")


def run_performance_tests(parallel=False, coverage=True, verbose=False):
    """Run performance tests"""
    cmd = [sys.executable, "-m", "pytest", "-m", "performance"]
    
    if parallel:
        cmd.extend(["-n", "auto"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing"])
    
    if verbose:
        cmd.extend(["-v", "-s"])
    
    cmd.append("tests/")
    
    return run_command(cmd, "Running performance tests")


def run_plugin_tests(parallel=False, coverage=True, verbose=False):
    """Run plugin system tests"""
    cmd = [sys.executable, "-m", "pytest", "-m", "plugin"]
    
    if parallel:
        cmd.extend(["-n", "auto"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing"])
    
    if verbose:
        cmd.extend(["-v", "-s"])
    
    cmd.append("tests/")
    
    return run_command(cmd, "Running plugin system tests")


def run_all_tests(parallel=False, coverage=True, verbose=False):
    """Run all tests"""
    cmd = [sys.executable, "-m", "pytest"]
    
    if parallel:
        cmd.extend(["-n", "auto"])
    
    if coverage:
        cmd.extend(["--cov=deb_mock", "--cov-report=term-missing", "--cov-report=html:htmlcov"])
    
    if verbose:
        cmd.extend(["-v", "-s"])
    
    cmd.append("tests/")
    
    return run_command(cmd, "Running all tests")


def generate_coverage_report():
    """Generate coverage report"""
    cmd = [sys.executable, "-m", "coverage", "report"]
    return run_command(cmd, "Generating coverage report")


def generate_html_coverage():
    """Generate HTML coverage report"""
    cmd = [sys.executable, "-m", "coverage", "html"]
    return run_command(cmd, "Generating HTML coverage report")


def run_linting():
    """Run code linting"""
    # Check if flake8 is available
    try:
        cmd = [sys.executable, "-m", "flake8", "deb_mock/", "tests/"]
        return run_command(cmd, "Running code linting")
    except FileNotFoundError:
        print("⚠️  flake8 not available, skipping linting")
        return None


def run_type_checking():
    """Run type checking"""
    # Check if mypy is available
    try:
        cmd = [sys.executable, "-m", "mypy", "deb_mock/"]
        return run_command(cmd, "Running type checking")
    except FileNotFoundError:
        print("⚠️  mypy not available, skipping type checking")
        return None


def run_security_scan():
    """Run security scanning"""
    # Check if bandit is available
    try:
        cmd = [sys.executable, "-m", "bandit", "-r", "deb_mock/"]
        return run_command(cmd, "Running security scan")
    except FileNotFoundError:
        print("⚠️  bandit not available, skipping security scan")
        return None


def main():
    """Main test runner"""
    parser = argparse.ArgumentParser(description="Comprehensive test runner for deb-mock")
    parser.add_argument("--unit", action="store_true", help="Run unit tests only")
    parser.add_argument("--integration", action="store_true", help="Run integration tests only")
    parser.add_argument("--performance", action="store_true", help="Run performance tests only")
    parser.add_argument("--plugin", action="store_true", help="Run plugin system tests only")
    parser.add_argument("--all", action="store_true", help="Run all tests")
    parser.add_argument("--parallel", action="store_true", help="Run tests in parallel")
    parser.add_argument("--no-coverage", action="store_true", help="Disable coverage reporting")
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
    parser.add_argument("--install-deps", action="store_true", help="Install test dependencies")
    parser.add_argument("--lint", action="store_true", help="Run code linting")
    parser.add_argument("--type-check", action="store_true", help="Run type checking")
    parser.add_argument("--security", action="store_true", help="Run security scanning")
    parser.add_argument("--coverage-report", action="store_true", help="Generate coverage report")
    
    args = parser.parse_args()
    
    print("🚀 deb-mock Test Runner")
    print("=" * 50)
    
    # Change to project directory
    project_dir = Path(__file__).parent
    os.chdir(project_dir)
    print(f"Working directory: {os.getcwd()}")
    
    # Install dependencies if requested
    if args.install_deps:
        install_test_dependencies()
    
    # Set coverage flag
    coverage = not args.no_coverage
    
    # Run specific test types
    if args.unit:
        run_unit_tests(args.parallel, coverage, args.verbose)
    elif args.integration:
        run_integration_tests(args.parallel, coverage, args.verbose)
    elif args.performance:
        run_performance_tests(args.parallel, coverage, args.verbose)
    elif args.plugin:
        run_plugin_tests(args.parallel, coverage, args.verbose)
    elif args.all:
        run_all_tests(args.parallel, coverage, args.verbose)
    else:
        # Default: run all tests
        run_all_tests(args.parallel, coverage, args.verbose)
    
    # Run additional checks if requested
    if args.lint:
        run_linting()
    
    if args.type_check:
        run_type_checking()
    
    if args.security:
        run_security_scan()
    
    if args.coverage_report:
        generate_coverage_report()
        generate_html_coverage()
    
    print("\n🎉 Test runner completed!")
    print("=" * 50)


if __name__ == "__main__":
    main()