#!/usr/bin/env python3
"""
Command-line interface for deb-mock
"""

import click
import sys
import os
from pathlib import Path
from .core import DebMock
from .config import Config
from .configs import get_available_configs, load_config
from .exceptions import (
    DebMockError, ConfigurationError, ChrootError, SbuildError, 
    BuildError, DependencyError, MetadataError, CacheError,
    PluginError, NetworkError, PermissionError, ValidationError,
    handle_exception, format_error_context
)


@click.group()
@click.version_option()
@click.option('--config', '-c', type=click.Path(exists=True), 
              help='Configuration file path')
@click.option('--chroot', '-r', help='Chroot configuration name (e.g., debian-bookworm-amd64)')
@click.option('--verbose', '-v', is_flag=True, help='Enable verbose output')
@click.option('--debug', is_flag=True, help='Enable debug output')
@click.pass_context
def main(ctx, config, chroot, verbose, debug):
    """
    Deb-Mock: A low-level utility to create clean, isolated build environments for Debian packages.
    
    This tool is a direct functional replacement for Fedora's Mock, adapted specifically 
    for Debian-based ecosystems.
    """
    ctx.ensure_object(dict)
    ctx.obj['verbose'] = verbose
    ctx.obj['debug'] = debug
    
    # Load configuration
    if config:
        try:
            ctx.obj['config'] = Config.from_file(config)
        except ConfigurationError as e:
            e.print_error()
            sys.exit(e.get_exit_code())
    elif chroot:
        # Load core config by name (similar to Mock's -r option)
        try:
            config_data = load_config(chroot)
            ctx.obj['config'] = Config(**config_data)
        except ValueError as e:
            error = ValidationError(
                f"Invalid chroot configuration: {e}",
                field='chroot',
                value=chroot,
                expected_format='debian-suite-arch or ubuntu-suite-arch'
            )
            error.print_error()
            click.echo(f"Available configs: {', '.join(get_available_configs())}")
            sys.exit(error.get_exit_code())
    else:
        ctx.obj['config'] = Config.default()


@main.command()
@click.argument('source_package', type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.option('--output-dir', '-o', type=click.Path(), 
              help='Output directory for build artifacts')
@click.option('--keep-chroot', is_flag=True, 
              help='Keep chroot after build (for debugging)')
@click.option('--no-check', is_flag=True, help='Skip running tests during build')
@click.option('--offline', is_flag=True, help='Build in offline mode (no network access)')
@click.option('--build-timeout', type=int, help='Build timeout in seconds')
@click.option('--force-arch', help='Force target architecture')
@click.option('--unique-ext', help='Unique extension for buildroot directory')
@click.option('--config-dir', help='Configuration directory')
@click.option('--cleanup-after', is_flag=True, help='Clean chroot after build')
@click.option('--no-cleanup-after', is_flag=True, help='Don\'t clean chroot after build')
@click.pass_context
@handle_exception
def build(ctx, source_package, chroot, arch, output_dir, keep_chroot, 
          no_check, offline, build_timeout, force_arch, unique_ext, 
          config_dir, cleanup_after, no_cleanup_after):
    """
    Build a Debian source package in an isolated environment.
    
    SOURCE_PACKAGE: Path to the .dsc file or source package directory
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
    if output_dir:
        ctx.obj['config'].output_dir = output_dir
    if keep_chroot:
        ctx.obj['config'].keep_chroot = keep_chroot
    if no_check:
        ctx.obj['config'].run_tests = False
    if offline:
        ctx.obj['config'].enable_network = False
    if build_timeout:
        ctx.obj['config'].build_timeout = build_timeout
    if force_arch:
        ctx.obj['config'].force_architecture = force_arch
    if unique_ext:
        ctx.obj['config'].unique_extension = unique_ext
    if config_dir:
        ctx.obj['config'].config_dir = config_dir
    if cleanup_after is not None:
        ctx.obj['config'].cleanup_after = cleanup_after
    if no_cleanup_after is not None:
        ctx.obj['config'].cleanup_after = not no_cleanup_after
        
    result = deb_mock.build(source_package)
    
    if ctx.obj['verbose']:
        click.echo(f"Build completed successfully: {result}")
    else:
        click.echo("Build completed successfully")


@main.command()
@click.argument('source_packages', nargs=-1, type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.option('--output-dir', '-o', type=click.Path(), 
              help='Output directory for build artifacts')
@click.option('--keep-chroot', is_flag=True, 
              help='Keep chroot after build (for debugging)')
@click.option('--continue-on-failure', is_flag=True,
              help='Continue building remaining packages even if one fails')
@click.pass_context
@handle_exception
def chain(ctx, source_packages, chroot, arch, output_dir, keep_chroot, continue_on_failure):
    """
    Build a chain of packages that depend on each other.
    
    SOURCE_PACKAGES: List of .dsc files or source package directories to build in order
    """
    if not source_packages:
        raise ValidationError(
            "No source packages specified",
            field='source_packages',
            expected_format='list of .dsc files or source directories'
        )
    
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
    if output_dir:
        ctx.obj['config'].output_dir = output_dir
    if keep_chroot:
        ctx.obj['config'].keep_chroot = keep_chroot
        
    results = deb_mock.build_chain(
        list(source_packages), 
        continue_on_failure=continue_on_failure
    )
    
    # Display results
    for result in results:
        if result['success']:
            click.echo(f"✅ {result['package']} (step {result['order']})")
        else:
            click.echo(f"❌ {result['package']} (step {result['order']}): {result['error']}")
            
    # Check if all builds succeeded
    failed_builds = [r for r in results if not r['success']]
    if failed_builds:
        sys.exit(1)
    else:
        click.echo("All packages built successfully")


@main.command()
@click.argument('chroot_name')
@click.option('--arch', help='Target architecture')
@click.option('--suite', help='Debian suite (e.g., bookworm, sid)')
@click.option('--bootstrap', is_flag=True, help='Use bootstrap chroot for cross-distribution builds')
@click.option('--bootstrap-chroot', help='Name of bootstrap chroot to use')
@click.pass_context
@handle_exception
def init_chroot(ctx, chroot_name, arch, suite, bootstrap, bootstrap_chroot):
    """
    Initialize a new chroot environment for building.
    
    CHROOT_NAME: Name of the chroot environment to create
    
    The --bootstrap option is useful for building packages for newer distributions
    on older systems (e.g., building Debian Sid packages on Debian Stable).
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if arch:
        ctx.obj['config'].architecture = arch
    if suite:
        ctx.obj['config'].suite = suite
    if bootstrap:
        ctx.obj['config'].use_bootstrap_chroot = True
    if bootstrap_chroot:
        ctx.obj['config'].bootstrap_chroot_name = bootstrap_chroot
        
    deb_mock.init_chroot(chroot_name)
    click.echo(f"Chroot '{chroot_name}' initialized successfully")
    
    if bootstrap:
        click.echo("Bootstrap chroot was used for cross-distribution compatibility")


@main.command()
@click.argument('chroot_name')
@click.pass_context
@handle_exception
def clean_chroot(ctx, chroot_name):
    """
    Clean up a chroot environment.
    
    CHROOT_NAME: Name of the chroot environment to clean
    """
    deb_mock = DebMock(ctx.obj['config'])
    deb_mock.clean_chroot(chroot_name)
    click.echo(f"Chroot '{chroot_name}' cleaned successfully")


@main.command()
@click.argument('chroot_name')
@click.pass_context
@handle_exception
def scrub_chroot(ctx, chroot_name):
    """
    Clean up a chroot environment without removing it.
    
    CHROOT_NAME: Name of the chroot environment to scrub
    """
    deb_mock = DebMock(ctx.obj['config'])
    deb_mock.chroot_manager.scrub_chroot(chroot_name)
    click.echo(f"Chroot '{chroot_name}' scrubbed successfully")


@main.command()
@click.pass_context
@handle_exception
def scrub_all_chroots(ctx):
    """
    Clean up all chroot environments without removing them.
    """
    deb_mock = DebMock(ctx.obj['config'])
    deb_mock.chroot_manager.scrub_all_chroots()
    click.echo("All chroots scrubbed successfully")


@main.command()
@click.option('--chroot', help='Chroot environment to use')
@click.option('--preserve-env', is_flag=True, help='Preserve environment variables in chroot')
@click.option('--env-var', multiple=True, help='Specific environment variable to preserve')
@click.pass_context
@handle_exception
def shell(ctx, chroot, preserve_env, env_var):
    """
    Open a shell in the chroot environment.
    
    Use --preserve-env to preserve environment variables (addresses common
    environment variable issues in chroot environments).
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    chroot_name = chroot or ctx.obj['config'].chroot_name
    
    # Configure environment preservation
    if preserve_env:
        ctx.obj['config'].environment_sanitization = False
    if env_var:
        ctx.obj['config'].preserve_environment.extend(env_var)
    
    deb_mock.shell(chroot_name)


@main.command()
@click.argument('source_path')
@click.argument('dest_path')
@click.option('--chroot', help='Chroot environment to use')
@click.pass_context
@handle_exception
def copyin(ctx, source_path, dest_path, chroot):
    """
    Copy files from host to chroot.
    
    SOURCE_PATH: Path to file/directory on host
    DEST_PATH: Path in chroot where to copy
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    chroot_name = chroot or ctx.obj['config'].chroot_name
    deb_mock.copyin(source_path, dest_path, chroot_name)
    click.echo(f"Copied {source_path} to {dest_path} in chroot '{chroot_name}'")


@main.command()
@click.argument('source_path')
@click.argument('dest_path')
@click.option('--chroot', help='Chroot environment to use')
@click.pass_context
@handle_exception
def copyout(ctx, source_path, dest_path, chroot):
    """
    Copy files from chroot to host.
    
    SOURCE_PATH: Path to file/directory in chroot
    DEST_PATH: Path on host where to copy
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    chroot_name = chroot or ctx.obj['config'].chroot_name
    deb_mock.copyout(source_path, dest_path, chroot_name)
    click.echo(f"Copied {source_path} from chroot '{chroot_name}' to {dest_path}")


@main.command()
@click.pass_context
@handle_exception
def list_chroots(ctx):
    """
    List available chroot environments.
    """
    deb_mock = DebMock(ctx.obj['config'])
    chroots = deb_mock.list_chroots()
    
    if not chroots:
        click.echo("No chroot environments found")
        return
        
    click.echo("Available chroot environments:")
    for chroot in chroots:
        click.echo(f"  - {chroot}")


@main.command()
@click.pass_context
@handle_exception
def list_configs(ctx):
    """
    List available core configurations.
    """
    from .configs import list_configs
    
    configs = list_configs()
    
    if not configs:
        click.echo("No core configurations found")
        return
        
    click.echo("Available core configurations:")
    for config_name, config_info in configs.items():
        click.echo(f"  - {config_name}: {config_info['description']}")
        click.echo(f"    Suite: {config_info['suite']}, Arch: {config_info['architecture']}")


@main.command()
@click.pass_context
@handle_exception
def cleanup_caches(ctx):
    """
    Clean up old cache files (similar to Mock's cache management).
    """
    deb_mock = DebMock(ctx.obj['config'])
    cleaned = deb_mock.cleanup_caches()
    
    if not cleaned:
        click.echo("No old cache files found to clean")
        return
    
    click.echo("Cleaned up cache files:")
    for cache_type, count in cleaned.items():
        if count > 0:
            click.echo(f"  - {cache_type}: {count} files")


@main.command()
@click.pass_context
@handle_exception
def cache_stats(ctx):
    """
    Show cache statistics.
    """
    deb_mock = DebMock(ctx.obj['config'])
    stats = deb_mock.get_cache_stats()
    
    if not stats:
        click.echo("No cache statistics available")
        return
    
    click.echo("Cache Statistics:")
    for cache_type, cache_stats in stats.items():
        click.echo(f"  - {cache_type}:")
        if isinstance(cache_stats, dict):
            for key, value in cache_stats.items():
                click.echo(f"    {key}: {value}")
        else:
            click.echo(f"    {cache_stats}")


@main.command()
@click.pass_context
@handle_exception
def config(ctx):
    """
    Show current configuration.
    """
    config = ctx.obj['config']
    click.echo("Current configuration:")
    click.echo(f"  Chroot name: {config.chroot_name}")
    click.echo(f"  Architecture: {config.architecture}")
    click.echo(f"  Suite: {config.suite}")
    click.echo(f"  Output directory: {config.output_dir}")
    click.echo(f"  Keep chroot: {config.keep_chroot}")
    click.echo(f"  Use root cache: {config.use_root_cache}")
    click.echo(f"  Use ccache: {config.use_ccache}")
    click.echo(f"  Parallel jobs: {config.parallel_jobs}")


@main.command()
@click.argument('source_package', type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.pass_context
@handle_exception
def install_deps(ctx, source_package, chroot, arch):
    """
    Install build dependencies for a Debian source package.
    
    SOURCE_PACKAGE: Path to the .dsc file or source package directory
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
        
    result = deb_mock.install_dependencies(source_package)
    
    if ctx.obj['verbose']:
        click.echo(f"Dependencies installed successfully: {result}")
    else:
        click.echo("Dependencies installed successfully")


@main.command()
@click.argument('packages', nargs=-1, required=True)
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.pass_context
@handle_exception
def install(ctx, packages, chroot, arch):
    """
    Install packages in the chroot environment.
    
    PACKAGES: List of packages to install
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
        
    result = deb_mock.install_packages(packages)
    
    if ctx.obj['verbose']:
        click.echo(f"Packages installed successfully: {result}")
    else:
        click.echo(f"Packages installed successfully: {', '.join(packages)}")


@main.command()
@click.argument('packages', nargs=-1)
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.pass_context
@handle_exception
def update(ctx, packages, chroot, arch):
    """
    Update packages in the chroot environment.
    
    PACKAGES: List of packages to update (if empty, update all)
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
        
    result = deb_mock.update_packages(packages)
    
    if ctx.obj['verbose']:
        click.echo(f"Packages updated successfully: {result}")
    else:
        if packages:
            click.echo(f"Packages updated successfully: {', '.join(packages)}")
        else:
            click.echo("All packages updated successfully")


@main.command()
@click.argument('packages', nargs=-1, required=True)
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.pass_context
@handle_exception
def remove(ctx, packages, chroot, arch):
    """
    Remove packages from the chroot environment.
    
    PACKAGES: List of packages to remove
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
        
    result = deb_mock.remove_packages(packages)
    
    if ctx.obj['verbose']:
        click.echo(f"Packages removed successfully: {result}")
    else:
        click.echo(f"Packages removed successfully: {', '.join(packages)}")


@main.command()
@click.argument('command')
@click.option('--chroot', help='Chroot environment to use')
@click.option('--arch', help='Target architecture')
@click.pass_context
@handle_exception
def apt_cmd(ctx, command, chroot, arch):
    """
    Execute APT command in the chroot environment.
    
    COMMAND: APT command to execute (e.g., "update", "install package")
    """
    deb_mock = DebMock(ctx.obj['config'])
    
    # Override config with command line options
    if chroot:
        ctx.obj['config'].chroot_name = chroot
    if arch:
        ctx.obj['config'].architecture = arch
        
    result = deb_mock.execute_apt_command(command)
    
    if ctx.obj['verbose']:
        click.echo(f"APT command executed successfully: {result}")
    else:
        click.echo(f"APT command executed: {command}")


@main.command()
@click.option('--expand', is_flag=True, help='Show expanded configuration values')
@click.pass_context
@handle_exception
def debug_config(ctx, expand):
    """
    Show detailed configuration information for debugging.
    """
    config = ctx.obj['config']
    
    if expand:
        # Show expanded configuration (with template values resolved)
        click.echo("Expanded Configuration:")
        config_dict = config.to_dict()
        for key, value in config_dict.items():
            click.echo(f"  {key}: {value}")
    else:
        # Show configuration with template placeholders
        click.echo("Configuration (with templates):")
        click.echo(f"  chroot_name: {config.chroot_name}")
        click.echo(f"  architecture: {config.architecture}")
        click.echo(f"  suite: {config.suite}")
        click.echo(f"  basedir: {config.basedir}")
        click.echo(f"  output_dir: {config.output_dir}")
        click.echo(f"  chroot_dir: {config.chroot_dir}")
        click.echo(f"  cache_dir: {config.cache_dir}")
        click.echo(f"  chroot_home: {config.chroot_home}")
        
        # Show plugin configuration
        if hasattr(config, 'plugins') and config.plugins:
            click.echo("  plugins:")
            for plugin_name, plugin_config in config.plugins.items():
                click.echo(f"    {plugin_name}: {plugin_config}")


if __name__ == '__main__':
    main()