"""Command-line interface for Video Library Manager.

This module provides the main CLI entry point using Click framework.
It implements global options (--config, --log-level) and error handling.
"""

import json
import sys
import traceback
from pathlib import Path
from typing import Optional

import click
import yaml

from vlm.config import Config, load_config, create_default_config, validate_config
from vlm.context import CLIContext, pass_context
from vlm.logging_config import setup_logging, get_logger
from vlm.utils import format_size


def default_config_path() -> Path:
    """Return the default config path resolved at runtime."""
    return Path.home() / ".vlm" / "config.yaml"


@click.group()
@click.option(
    '--config',
    type=click.Path(path_type=Path),
    default=default_config_path,
    help='Path to configuration file (default: ~/.vlm/config.yaml)'
)
@click.option(
    '--log-level',
    type=click.Choice(['DEBUG', 'INFO', 'WARNING', 'ERROR'], case_sensitive=False),
    default=None,
    help='Set logging level (overrides config file)'
)
@click.pass_context
def main(ctx, config: Path, log_level: Optional[str]):
    """Video Library Manager - A tool for managing personal video collections.
    
    VLM helps you organize, analyze, and maintain your video library with a
    safety-first approach. All operations are reversible and require explicit
    confirmation before making changes.
    
    Common workflow:
    
      1. vlm scan              - Discover all video files
      2. vlm parse             - Extract titles, years, seasons, episodes
      3. vlm analyze           - Detect gaps and duplicates
      4. vlm plan              - Generate execution plan
      5. vlm execute           - Execute plan (dry-run by default)
      6. vlm execute --confirm - Actually execute operations
    
    Use 'vlm COMMAND --help' for more information on a specific command.
    """
    # Ensure context object exists
    ctx.ensure_object(dict)
    
    try:
        # Load or create configuration
        if config.exists():
            try:
                cfg = load_config(config)
            except yaml.YAMLError as e:
                click.echo(f"Error: Invalid YAML syntax in configuration file: {e}", err=True)
                click.echo("Using default configuration values.", err=True)
                cfg = create_default_config(config)
            except ValueError as e:
                click.echo(f"Error: {e}", err=True)
                click.echo("Using default configuration values.", err=True)
                cfg = create_default_config(config)
        else:
            click.echo(f"Configuration file not found at {config}", err=True)
            click.echo("Creating default configuration...", err=True)
            cfg = create_default_config(config)
            click.echo(f"Default configuration created at {config}", err=True)
        
        # Validate configuration
        validation_errors = validate_config(cfg)
        if validation_errors:
            click.echo("Configuration validation errors:", err=True)
            for error in validation_errors:
                click.echo(f"  - {error}", err=True)
            click.echo("Please fix the configuration file and try again.", err=True)
            sys.exit(1)
        
        # Override log level if specified on command line
        if log_level:
            cfg.log_level = log_level.upper()
        
        # Set up logging
        logger = setup_logging(log_level=cfg.log_level)
        
        # Store context for subcommands
        ctx.obj = CLIContext(config=cfg, logger=logger)
        
    except Exception as e:
        traceback.print_exc(file=sys.stderr)
        click.echo(f"Error initializing VLM: {e}", err=True)
        sys.exit(1)


@main.command()
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=Path('inventory.csv'),
    help='Output file for inventory (default: inventory.csv)'
)
@click.option(
    '--metadata/--no-metadata',
    default=True,
    help='Extract video metadata via ffprobe (default: enabled)'
)
@click.option(
    '--reuse-from',
    type=click.Path(exists=True, path_type=Path),
    default=None,
    help='Reuse metadata cache from an existing inventory CSV (default: output file if it exists)'
)
@click.option(
    '--force-refresh-metadata',
    is_flag=True,
    default=False,
    help='Ignore metadata cache and re-run ffprobe for all files'
)
@pass_context
def scan(
    ctx: CLIContext,
    output: Path,
    metadata: bool,
    reuse_from: Optional[Path],
    force_refresh_metadata: bool
):
    """Scan library and generate inventory.
    
    Discovers all video files in the library and records their metadata.
    This is a read-only operation that does not modify any files.
    
    Example:
    
        vlm scan                          # Save to inventory.csv
        vlm scan --output my_library.csv  # Save to custom file
        vlm scan --no-metadata            # Faster scan without ffprobe
        vlm scan --reuse-from old.csv     # Reuse prior metadata cache
        vlm scan --force-refresh-metadata # Re-run ffprobe for all files
    """
    try:
        from vlm.commands.scan import scan_cmd
        scan_cmd(ctx, output, metadata, reuse_from, force_refresh_metadata)
    except Exception as e:
        click.echo(f"Error during scan: {e}", err=True)
        ctx.logger.error(f"Scan failed: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('inventory.csv'),
    help='Input inventory CSV file (default: inventory.csv)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=Path('identities.json'),
    help='Output file for parsed identities (default: identities.json)'
)
@click.option(
    '--inventory',
    type=click.Path(exists=True, path_type=Path),
    default=None,
    help='Inventory CSV to embed video metadata (enables v2 schema with quality data)'
)
@pass_context
def parse(ctx: CLIContext, input: Path, output: Path, inventory: Optional[Path]):
    """Parse identities from filenames.

    Extracts movie titles, years, series titles, seasons, and episodes
    from video filenames in the inventory.

    Use --inventory to embed video metadata (size, resolution, codec) in the output,
    which enables accurate duplicate resolution by quality in the analyze stage.

    Example:

        vlm parse                                    # Use default files (v1 schema)
        vlm parse --inventory inventory.csv          # Embed metadata (v2 schema)
        vlm parse --input my_inventory.csv           # Custom input
        vlm parse --output parsed_identities.json    # Custom output
    """
    from datetime import datetime, timezone
    from vlm.parser import parse_movie, parse_series
    from vlm.io import load_inventory_csv, save_identities_json

    config = ctx.config
    logger = ctx.logger

    try:
        # Display parse start message
        click.echo(f"Parsing identities from: {input}")

        # Load video metadata from inventory if provided
        path_to_metadata = {}
        if inventory:
            click.echo(f"Loading video metadata from: {inventory}")
            inventory_files = load_inventory_csv(inventory)
            path_to_metadata = {str(vf.path): vf for vf in inventory_files}
            click.echo(f"Loaded metadata for {len(path_to_metadata)} files")

        click.echo()

        # Load inventory via unified I/O layer
        inventory_files = load_inventory_csv(input)
        video_files = [
            {
                'path': str(vf.path),
                'filename': vf.filename,
                'category': vf.category,
            }
            for vf in inventory_files
        ]

        click.echo(f"Loaded {len(video_files)} files from inventory")
        click.echo()
        
        # Parse identities based on category
        movie_identities = []
        series_identities = []
        anime_files = []
        other_files = []

        def get_video_metadata(file_path: str) -> dict:
            """Extract video metadata from inventory if available."""
            if not path_to_metadata:
                return {}
            vf = path_to_metadata.get(file_path)
            if not vf:
                return {}
            return {
                'size_bytes': vf.size_bytes,
                'modified_timestamp': vf.modified_timestamp.isoformat(),
                'resolution': vf.resolution,
                'codec': vf.codec,
                'duration_seconds': vf.duration_seconds,
                'bitrate_kbps': vf.bitrate_kbps,
            }

        for vf in video_files:
            filename = vf['filename']
            category = vf['category']
            file_path = vf['path']
            video_metadata = get_video_metadata(file_path)

            if category == 'movie':
                identity = parse_movie(filename, extensions=config.video_extensions)
                record = {
                    'path': file_path,
                    'filename': filename,
                    'category': category,
                    'title': identity.title,
                    'year': identity.year,
                    'confidence': identity.confidence,
                    'needs_review': identity.needs_review
                }
                if video_metadata:
                    record['video_metadata'] = video_metadata
                movie_identities.append(record)

            elif category == 'series':
                identity = parse_series(filename, extensions=config.video_extensions)
                record = {
                    'path': file_path,
                    'filename': filename,
                    'category': category,
                    'title': identity.title,
                    'season': identity.season,
                    'episodes': identity.episodes,
                    'confidence': identity.confidence,
                    'needs_review': identity.needs_review
                }
                if video_metadata:
                    record['video_metadata'] = video_metadata
                series_identities.append(record)
            
            elif category == 'anime':
                # Anime files are not parsed in v1
                anime_files.append({
                    'path': vf['path'],
                    'filename': filename,
                    'category': category,
                    'note': 'Anime parsing deferred in v1'
                })
            
            else:
                # Other files are not parsed
                other_files.append({
                    'path': vf['path'],
                    'filename': filename,
                    'category': category,
                    'note': 'Not categorized for parsing'
                })
        
        # Display parsing statistics
        click.echo("Parsing complete!")
        click.echo()
        click.echo("Results by category:")
        click.echo(f"  Movies: {len(movie_identities)}")
        
        # Count movies needing review
        movies_need_review = sum(1 for m in movie_identities if m['needs_review'])
        if movies_need_review > 0:
            click.echo(f"    - Need review: {movies_need_review}")
        
        click.echo(f"  Series: {len(series_identities)}")
        
        # Count series needing review
        series_need_review = sum(1 for s in series_identities if s['needs_review'])
        if series_need_review > 0:
            click.echo(f"    - Need review: {series_need_review}")
        
        click.echo(f"  Anime: {len(anime_files)} (not parsed in v1)")
        click.echo(f"  Other: {len(other_files)} (not parsed)")
        
        # Save parsed identities to JSON
        click.echo()
        click.echo(f"Saving parsed identities to: {output}")
        
        # Ensure output directory exists
        output.parent.mkdir(parents=True, exist_ok=True)
        
        # Build JSON structure
        generation_timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S")

        # Use v2 schema if video metadata was embedded
        schema_version = "2.0" if path_to_metadata else "1.0"

        identities_data = {
            'vlm_schema_version': schema_version,
            'metadata': {
                'generated': generation_timestamp,
                'source_inventory': str(input),
                'total_files': len(video_files)
            },
            'movies': movie_identities,
            'series': series_identities,
            'anime': anime_files,
            'other': other_files
        }
        
        # Write JSON via unified I/O layer
        save_identities_json(identities_data, output)
        
        click.echo(f"Parsed identities saved successfully!")
        
        logger.info(f"Parse completed: {len(movie_identities)} movies, {len(series_identities)} series, saved to {output}")
        
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error during parsing: {e}", err=True)
        logger.error(f"Parse failed: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('identities.json'),
    help='Path to identities JSON file (default: identities.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=None,
    help='Output path (default: overwrite input file)'
)
@click.option(
    '--refresh-changed-only',
    is_flag=True,
    default=False,
    help='Refresh only records whose identity fingerprint changed (incremental behavior)'
)
@click.option(
    '--refresh-all',
    is_flag=True,
    default=False,
    help='Bypass cache and re-enrich all records'
)
@click.option(
    '--timeout',
    type=int,
    default=6,
    show_default=True,
    help='Per-request timeout in seconds'
)
@click.option(
    '--retries',
    type=int,
    default=2,
    show_default=True,
    help='Retry attempts for provider/API requests'
)
@pass_context
def enrich(
    ctx: CLIContext,
    input: Path,
    output: Optional[Path],
    refresh_changed_only: bool,
    refresh_all: bool,
    timeout: int,
    retries: int,
):
    """Enrich identities with translation and reputation metadata.

    Applies incremental cache-backed enrichment to parsed identities and writes
    results back into identities JSON.
    """
    import json
    from vlm.enrichment import enrich_identities_data

    config = ctx.config
    logger = ctx.logger

    if output is None:
        output = input

    try:
        click.echo(f"Enriching identities from: {input}")
        click.echo(f"Output file: {output}")
        click.echo()

        with open(input, 'r', encoding='utf-8') as jsonfile:
            identities_data = json.load(jsonfile)

        if refresh_all and refresh_changed_only:
            click.echo("Error: --refresh-all and --refresh-changed-only are mutually exclusive.", err=True)
            sys.exit(1)

        if timeout < 1:
            click.echo("Error: --timeout must be >= 1", err=True)
            sys.exit(1)

        if retries < 0:
            click.echo("Error: --retries must be >= 0", err=True)
            sys.exit(1)

        refresh_mode = "incremental"
        if refresh_all:
            refresh_mode = "refresh_all"
        elif refresh_changed_only:
            refresh_mode = "refresh_changed_only"

        total = (
            len(identities_data.get('movies', []))
            + len(identities_data.get('series', []))
            + len(identities_data.get('anime', []))
        )

        progress_state: dict[str, Optional[click.ProgressBar]] = {"bar": None}
        progress_position = {"current": 0}
        progress_bucket = {"value": -1}
        is_tty = bool(getattr(sys.stderr, "isatty", lambda: False)())

        def _enrich_progress(processed: int, total_count: int, metrics: dict[str, int]) -> None:
            if total_count <= 0:
                return

            if is_tty and progress_state["bar"] is None:
                bar = click.progressbar(
                    length=total_count,
                    label="Enriching records",
                    show_pos=True,
                )
                progress_state["bar"] = bar.__enter__()

            step = processed - progress_position["current"]
            if step > 0 and progress_state["bar"] is not None:
                progress_state["bar"].update(step)
                progress_position["current"] = processed

            if not is_tty:
                percent = int(processed * 100 / total_count)
                bucket = percent // 5
                if bucket > progress_bucket["value"] or processed == total_count:
                    progress_bucket["value"] = bucket
                    click.echo(
                        "Progress: "
                        f"{processed}/{total_count} ({percent}%) "
                        f"api_calls={metrics.get('api_calls', 0)} "
                        f"cache_hits={metrics.get('cache_hits', 0)} "
                        f"failed={metrics.get('failed', 0)}"
                    )

        try:
            if total == 0:
                click.echo("No movie/series/anime records found to enrich.")
            enriched_data, stats = enrich_identities_data(
                identities_data,
                config,
                refresh_mode=refresh_mode,
                request_timeout=timeout,
                retries=retries,
                logger=logger,
                progress_callback=_enrich_progress,
            )
        finally:
            if progress_state["bar"] is not None:
                progress_state["bar"].__exit__(None, None, None)
                click.echo()

        output.parent.mkdir(parents=True, exist_ok=True)
        with open(output, 'w', encoding='utf-8') as jsonfile:
            json.dump(enriched_data, jsonfile, indent=2, ensure_ascii=False)

        total_records = int(stats['total']) if stats['total'] else 0
        cache_hits = int(stats['cache_hits'])
        hit_rate = (cache_hits / total_records * 100.0) if total_records else 0.0

        click.echo("Enrichment complete!")
        click.echo(f"  Total records: {total_records}")
        click.echo(f"  Refresh mode: {refresh_mode}")
        click.echo(f"  Enriched now: {stats['enriched']}")
        click.echo(f"  Cache hits: {stats['cache_hits']}")
        click.echo(f"  Cache hit rate: {hit_rate:.1f}%")
        click.echo(f"  API calls: {stats['api_calls']}")
        click.echo(f"  Failed requests: {stats['failed']}")
        click.echo(f"  Skipped: {stats['skipped']}")
        click.echo(f"  Needs review: {stats['needs_review']}")
        skip_reasons = stats.get("skip_reasons", {})
        if isinstance(skip_reasons, dict):
            non_zero = [f"{name}={count}" for name, count in sorted(skip_reasons.items()) if int(count) > 0]
            if non_zero:
                click.echo(f"  Skip reasons: {' '.join(non_zero)}")
        failed_items = stats.get('failed_items', [])
        if isinstance(failed_items, list) and failed_items:
            click.echo("  Failure sample:")
            for item in failed_items[:3]:
                click.echo(
                    f"    - [{item.get('provider', 'unknown')}] {item.get('title', '')}: {item.get('reason', '')}"
                )

        logger.info(
            "Enrich completed: total=%s enriched=%s cache_hits=%s failed=%s skipped=%s mode=%s",
            stats['total'],
            stats['enriched'],
            stats['cache_hits'],
            stats['failed'],
            stats['skipped'],
            refresh_mode,
        )
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse JSON file: {e}", err=True)
        logger.error(f"JSON parsing failed during enrich: {e}", exc_info=True)
        sys.exit(1)
    except Exception as e:
        click.echo(f"Error during enrichment: {e}", err=True)
        logger.error(f"Enrich failed: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('identities.json'),
    help='Path to parsed identities JSON file (default: identities.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=Path('analysis.json'),
    help='Path to save analysis results (default: analysis.json)'
)
@click.option(
    '--inventory',
    type=click.Path(exists=True, path_type=Path),
    default=None,
    help='Optional inventory CSV to merge size/resolution/codec for duplicate quality comparison'
)
@pass_context
def analyze(ctx: CLIContext, input: Path, output: Path, inventory: Optional[Path]):
    """Analyze completeness and duplicates.
    
    Detects episode gaps in series and identifies potential duplicate files.
    Provides quality comparison data for duplicates.
    
    Example:
    
        vlm analyze                                  # Use default files
        vlm analyze --input my_identities.json       # Custom input
        vlm analyze --inventory inventory.csv       # Merge metadata for quality comparison
        vlm analyze --output my_analysis.json        # Custom output
    """
    try:
        from vlm.commands.analyze import analyze_cmd
        analyze_cmd(ctx, input, output, inventory)
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        ctx.logger.error(f"Input file not found: {input}")
        sys.exit(1)
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse JSON file: {e}", err=True)
        ctx.logger.error(f"JSON parsing failed: {e}", exc_info=True)
        sys.exit(1)
    except Exception as e:
        click.echo(f"Error during analysis: {e}", err=True)
        ctx.logger.error(f"Analysis failed: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('identities.json'),
    help='Path to parsed identities JSON file (default: identities.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=Path('plan.json'),
    help='Path to save execution plan (default: plan.json)'
)
@click.option(
    '--analysis',
    type=click.Path(path_type=Path),
    default=None,
    help='Path to analysis JSON (optional); when provided, duplicate groups are applied to the plan'
)
@pass_context
def plan(ctx: CLIContext, input: Path, output: Path, analysis: Path | None):
    """Generate execution plan.
    
    Creates a structured, reviewable plan of all file operations to be performed.
    The plan can be edited before execution.
    
    Example:
    
        vlm plan                                  # Use default files
        vlm plan --input my_identities.json       # Custom input
        vlm plan --analysis analysis.json         # Use analysis for duplicate handling
        vlm plan --output my_plan.json            # Custom output
    """
    try:
        from vlm.commands.plan import plan_cmd
        plan_cmd(ctx, input, output, analysis)
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        ctx.logger.error(f"Input file not found: {input}")
        sys.exit(1)
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse JSON file: {e}", err=True)
        ctx.logger.error(f"JSON parsing failed: {e}", exc_info=True)
        sys.exit(1)
    except Exception as e:
        click.echo(f"Error during plan generation: {e}", err=True)
        ctx.logger.error(f"Plan generation failed: {e}", exc_info=True)
        sys.exit(1)


@main.command(name="review-plan")
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('plan.json'),
    help='Path to execution plan JSON file (default: plan.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=Path('plan_manual_review.csv'),
    help='Path to save manual review CSV (default: plan_manual_review.csv)'
)
@click.option(
    '--season-threshold',
    type=int,
    default=20,
    show_default=True,
    help='Flag operations with season >= this value as high risk'
)
@click.option(
    '--episode-threshold',
    type=int,
    default=40,
    show_default=True,
    help='Flag operations with episode >= this value as high risk'
)
@pass_context
def review_plan_cmd(
    ctx: CLIContext,
    input: Path,
    output: Path,
    season_threshold: int,
    episode_threshold: int,
):
    """Review a plan and export high-risk operations for manual confirmation."""
    from vlm.planner import load_plan
    from vlm.plan_review import review_plan, save_review_csv

    logger = ctx.logger

    try:
        if season_threshold < 1 or episode_threshold < 1:
            click.echo("Error: thresholds must be >= 1", err=True)
            sys.exit(1)

        click.echo(f"Loading plan: {input}")
        execution_plan = load_plan(input)
        rows, counters = review_plan(
            execution_plan,
            season_threshold=season_threshold,
            episode_threshold=episode_threshold,
        )

        save_review_csv(rows, output)

        click.echo()
        click.echo("Plan review summary:")
        click.echo(f"  Total operations: {counters['total_operations']}")
        click.echo(f"  High-risk operations: {counters['high_risk_operations']}")
        click.echo(f"  manual_review: {counters['manual_review']}")
        click.echo(f"  sample_source: {counters['sample_source']}")
        click.echo(f"  high_season: {counters['high_season']}")
        click.echo(f"  high_episode: {counters['high_episode']}")
        click.echo(f"  conflicts: {counters['conflicts']}")
        click.echo()
        click.echo(f"Saved manual review CSV to: {output}")

        if rows:
            click.echo("Top review samples:")
            for row in rows[:5]:
                click.echo(
                    f"  - [{row['index']}] {row['operation_type']} {Path(row['source_path']).name} ({row['risk_flags']})"
                )

        logger.info(
            "Plan review completed: total=%s high_risk=%s output=%s",
            counters["total_operations"],
            counters["high_risk_operations"],
            output,
        )
    except FileNotFoundError:
        click.echo(f"Error: Plan file not found: {input}", err=True)
        logger.error(f"Plan file not found: {input}")
        sys.exit(1)
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse plan JSON: {e}", err=True)
        logger.error(f"Plan review JSON parsing failed: {e}", exc_info=True)
        sys.exit(1)
    except Exception as e:
        click.echo(f"Error during plan review: {e}", err=True)
        logger.error(f"Plan review failed: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--plan',
    type=click.Path(exists=True, path_type=Path),
    default=Path('plan.json'),
    help='Path to execution plan JSON file (default: plan.json)'
)
@click.option(
    '--confirm',
    is_flag=True,
    default=False,
    help='Actually execute operations (default is dry-run)'
)
@click.option(
    '--yes',
    is_flag=True,
    default=False,
    help='Skip confirmation prompt (auto-approve)'
)
@click.option(
    '--verbose-ops',
    is_flag=True,
    default=False,
    help='Print per-operation dry-run logs at INFO level'
)
@pass_context
def execute(ctx: CLIContext, plan: Path, confirm: bool, yes: bool, verbose_ops: bool):
    """Execute plan (defaults to dry-run, requires --confirm).

    Executes file operations from a plan. Defaults to dry-run mode which
    simulates operations without making changes. Use --confirm to actually
    execute operations.

    Example:

        vlm execute                      # Dry-run with plan.json
        vlm execute --plan my_plan.json  # Dry-run with custom plan
        vlm execute --confirm            # Actually execute operations (with prompt)
        vlm execute --confirm --yes      # Execute without confirmation prompt
    """
    from vlm.planner import load_plan
    from vlm.executor import ExecutionEngine
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Determine execution mode
        mode = "execute" if confirm else "dry-run"
        
        # Display execution start message
        click.echo(f"Loading execution plan from: {plan}")
        click.echo()
        
        # Load execution plan
        execution_plan = load_plan(plan)
        
        # Display plan summary
        click.echo(f"Execution plan loaded: {execution_plan.plan_id}")
        click.echo(f"Created at: {execution_plan.created_at}")
        click.echo(f"Total operations: {len(execution_plan.operations)}")
        if execution_plan.human_summary:
            click.echo()
            click.echo(execution_plan.human_summary)
        elif execution_plan.summary or execution_plan.summary_by_reason:
            s = execution_plan.summary or {}
            by_r = execution_plan.summary_by_reason or {}
            parts = [f"操作统计：共 {s.get('total', len(execution_plan.operations))} 条（move {s.get('move', 0)}，rename {s.get('rename', 0)}，quarantine {s.get('quarantine', 0)}，no-op {s.get('no-op', 0)}）"]
            if by_r:
                parts.append("原因分布：" + "；".join(f"{r}: {c}" for r, c in list(by_r.items())[:5]))
            click.echo()
            click.echo("\n".join(parts))
        click.echo()
        
        # Display mode warning
        if mode == "dry-run":
            click.echo("⚠️  DRY-RUN MODE - No files will be modified")
            click.echo("   Use --confirm to actually execute operations")
        else:
            click.echo("⚠️  EXECUTE MODE - Files will be modified!")
            click.echo("   This operation cannot be undone without rollback")
            click.echo()
            if not yes:
                if not click.confirm("Are you sure you want to proceed?"):
                    click.echo("Execution cancelled.")
                    return
            else:
                click.echo("Auto-approved via --yes flag")
        
        click.echo()
        click.echo(f"Executing {len(execution_plan.operations)} operations...")
        click.echo()
        
        # Load state manager to update file statuses during execution
        from vlm.state import StateManager
        state_path = Path.home() / ".vlm" / "state.json"
        state_manager = StateManager(state_path)

        # Create execution engine and execute plan
        engine = ExecutionEngine(
            logger=logger, 
            config=config, 
            verbose_operations=verbose_ops,
            state_manager=state_manager
        )
        results, summary, rollback_log = engine.execute_plan(
            execution_plan,
            mode=mode,
            confirmed=confirm
        )
        
        # Display execution progress (show some operations)
        if mode == "dry-run":
            click.echo("Sample operations (dry-run):")
            # Show first 5 operations as examples
            for i, result in enumerate(results[:5]):
                op = result.operation
                if op.operation_type != "no-op":
                    click.echo(f"  [{i+1}] {op.operation_type}: {op.source_path.name}")
                    if op.destination_path:
                        click.echo(f"      -> {op.destination_path}")
            
            if len(results) > 5:
                click.echo(f"  ... and {len(results) - 5} more operations")
        else:
            # In execute mode, show progress for all operations
            for i, result in enumerate(results):
                op = result.operation
                if op.operation_type != "no-op" and not op.has_conflict:
                    status = "✓" if result.success else "✗"
                    click.echo(f"  [{i+1}/{len(results)}] {status} {op.operation_type}: {op.source_path.name}")
                    if result.error_message:
                        click.echo(f"      Error: {result.error_message}")
        
        # Display execution summary
        click.echo()
        click.echo("=" * 60)
        click.echo(f"Execution Summary ({mode} mode)")
        click.echo("=" * 60)
        click.echo(f"  Total operations: {summary['total']}")
        click.echo(f"  Successful: {summary['successful']}")
        click.echo(f"  Failed: {summary['failed']}")
        click.echo(f"  Skipped: {summary['skipped']}")
        click.echo()
        
        # Save rollback log if in execute mode
        if mode == "execute" and rollback_log:
            # Save to ~/.vlm/rollback/ directory
            rollback_dir = Path.home() / ".vlm" / "rollback"
            rollback_dir.mkdir(parents=True, exist_ok=True)
            rollback_path = rollback_dir / f"rollback_{rollback_log.log_id}.json"
            
            engine.save_rollback_log(rollback_log, rollback_path)
            
            click.echo(f"Rollback log saved to: {rollback_path}")
            click.echo()
            click.echo("To undo these operations, run:")
            click.echo(f"  vlm rollback --log {rollback_path}")
            click.echo()
        
        # Log completion
        if mode == "dry-run":
            click.echo("Dry-run complete! No files were modified.")
            click.echo("Review the operations above and use --confirm to execute.")
        else:
            if summary['failed'] > 0:
                click.echo(f"⚠️  Execution completed with {summary['failed']} failures.")
                click.echo("   Check the log file for details.")
            else:
                click.echo("✓ Execution completed successfully!")
        
        logger.info(
            f"Execution completed in {mode} mode: "
            f"{summary['successful']} successful, {summary['failed']} failed, {summary['skipped']} skipped"
        )
        
    except FileNotFoundError:
        click.echo(f"Error: Plan file not found: {plan}", err=True)
        logger.error(f"Plan file not found: {plan}")
        sys.exit(1)
    
    except ValueError as e:
        click.echo(f"Error: {e}", err=True)
        logger.error(f"Execution failed: {e}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error during execution: {e}", err=True)
        logger.error(f"Execution failed: {e}", exc_info=True)
        sys.exit(1)


@main.group()
@pass_context
def quarantine(ctx: CLIContext):
    """Manage quarantined files.
    
    Quarantine operations allow you to safely isolate unwanted files
    for review before deletion. Only movie and series files can be
    quarantined in v1.
    """
    pass


@quarantine.command('list')
@click.option(
    '--category',
    type=click.Choice(['movie', 'series'], case_sensitive=False),
    default=None,
    help='Filter by category (movie or series)'
)
@pass_context
def quarantine_list(ctx: CLIContext, category: Optional[str]):
    """List quarantined files.
    
    Shows all files currently in quarantine with their original locations,
    quarantine timestamps, and reasons.
    
    Example:
    
        vlm quarantine list                  # List all quarantined files
        vlm quarantine list --category movie # List only movie files
    """
    from vlm.quarantine import QuarantineManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Create quarantine manager
        manager = QuarantineManager(config, logger)
        
        # List quarantined files
        entries = manager.list_quarantined(category=category)
        
        if not entries:
            if category:
                click.echo(f"No quarantined files found in category '{category}'.")
            else:
                click.echo("No quarantined files found.")
            return
        
        # Display quarantined files
        click.echo()
        if category:
            click.echo(f"Quarantined files in category '{category}':")
        else:
            click.echo("Quarantined files:")
        click.echo("=" * 80)
        
        for i, entry in enumerate(entries, 1):
            click.echo(f"\n[{i}] {entry.quarantine_path.name}")
            click.echo(f"    Category: {entry.category}")
            click.echo(f"    Original: {entry.original_path}")
            click.echo(f"    Quarantine: {entry.quarantine_path}")
            click.echo(f"    Size: {format_size(entry.size_bytes)}")
            click.echo(f"    Quarantined: {entry.quarantined_at.strftime('%Y-%m-%d %H:%M:%S')}")
            if entry.reason:
                click.echo(f"    Reason: {entry.reason}")
        
        click.echo()
        click.echo("=" * 80)
        click.echo(f"Total: {len(entries)} quarantined file(s)")
        click.echo()
        
        logger.info(f"Listed {len(entries)} quarantined files" + 
                   (f" from category '{category}'" if category else ""))
        
    except Exception as e:
        click.echo(f"Error listing quarantined files: {e}", err=True)
        logger.error(f"Failed to list quarantined files: {e}", exc_info=True)
        sys.exit(1)


@quarantine.command('add')
@click.argument('file', type=click.Path(exists=True, path_type=Path))
@click.option(
    '--reason',
    type=str,
    default=None,
    help='Reason for quarantining the file'
)
@pass_context
def quarantine_add(ctx: CLIContext, file: Path, reason: Optional[str]):
    """Add file to quarantine.
    
    Moves a file to the category-specific quarantine directory. Only movie
    and series files can be quarantined in v1. Anime and other files will
    be rejected.
    
    Example:
    
        vlm quarantine add /path/to/movie.mkv
        vlm quarantine add /path/to/series.mkv --reason "duplicate"
    """
    from vlm.quarantine import QuarantineManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Create quarantine manager
        manager = QuarantineManager(config, logger)
        
        # Display confirmation
        click.echo(f"Quarantining file: {file}")
        if reason:
            click.echo(f"Reason: {reason}")
        click.echo()
        
        # Quarantine the file
        result = manager.quarantine_file(file, reason=reason)
        
        if result.success:
            click.echo(f"✓ File successfully quarantined!")
            click.echo(f"  Original: {result.operation.source_path}")
            click.echo(f"  Quarantine: {result.operation.destination_path}")
            click.echo()
            click.echo("To restore this file, run:")
            click.echo(f"  vlm quarantine restore {result.operation.destination_path}")
        else:
            click.echo(f"✗ Failed to quarantine file: {result.error_message}", err=True)
            sys.exit(1)
        
        logger.info(f"Quarantined file: {file}")
        
    except ValueError as e:
        # Category restriction error
        click.echo(f"Error: {e}", err=True)
        logger.error(f"Quarantine rejected: {e}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error quarantining file: {e}", err=True)
        logger.error(f"Failed to quarantine file: {e}", exc_info=True)
        sys.exit(1)


@quarantine.command('restore')
@click.argument('file', type=click.Path(exists=True, path_type=Path))
@pass_context
def quarantine_restore(ctx: CLIContext, file: Path):
    """Restore file from quarantine.
    
    Moves a file from quarantine back to its original location. This is a
    best-effort operation that may fail if the original location is occupied.
    
    Example:
    
        vlm quarantine restore /path/to/.quarantine/movie.mkv
    """
    from vlm.quarantine import QuarantineManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Create quarantine manager
        manager = QuarantineManager(config, logger)
        
        # Display confirmation
        click.echo(f"Restoring file from quarantine: {file}")
        click.echo()
        
        # Restore the file
        result = manager.restore_from_quarantine(file)
        
        if result.success:
            click.echo(f"✓ File successfully restored!")
            click.echo(f"  Quarantine: {result.operation.source_path}")
            click.echo(f"  Restored to: {result.operation.destination_path}")
        else:
            if result.operation.has_conflict:
                click.echo(f"✗ Cannot restore: {result.operation.conflict_reason}", err=True)
                click.echo(f"  Original location: {result.operation.destination_path}", err=True)
            else:
                click.echo(f"✗ Failed to restore file: {result.error_message}", err=True)
            sys.exit(1)
        
        logger.info(f"Restored file from quarantine: {file}")
        
    except Exception as e:
        click.echo(f"Error restoring file: {e}", err=True)
        logger.error(f"Failed to restore file: {e}", exc_info=True)
        sys.exit(1)


@main.command()
@click.option(
    '--log',
    type=click.Path(exists=True, path_type=Path),
    default=None,
    help='Path to rollback log JSON file'
)
@pass_context
def rollback(ctx: CLIContext, log: Optional[Path]):
    """Rollback previous execution (best-effort).
    
    Attempts to reverse file operations from a previous execution by moving
    files from their destination back to their source. This is a best-effort
    operation that may not succeed if files have been modified or moved.
    
    Operations are processed in LIFO (Last In, First Out) order for best-effort
    restoration. All rollback attempts are logged with detailed results.
    
    Example:
    
        vlm rollback                                    # Find latest rollback log
        vlm rollback --log rollback_<uuid>.json         # Use specific log
        vlm rollback --log ~/.vlm/rollback/rollback_*.json
    """
    from vlm.executor import ExecutionEngine
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # If no log specified, find the most recent rollback log
        if log is None:
            rollback_dir = Path.home() / ".vlm" / "rollback"
            if not rollback_dir.exists():
                click.echo("Error: No rollback logs found.", err=True)
                click.echo(f"Rollback directory does not exist: {rollback_dir}", err=True)
                sys.exit(1)
            
            # Find all rollback log files
            rollback_logs = sorted(rollback_dir.glob("rollback_*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
            
            if not rollback_logs:
                click.echo("Error: No rollback logs found.", err=True)
                click.echo(f"No rollback_*.json files in: {rollback_dir}", err=True)
                sys.exit(1)
            
            # Use the most recent log
            log = rollback_logs[0]
            click.echo(f"Using most recent rollback log: {log}")
            click.echo()
        
        # Display rollback start message
        click.echo(f"Loading rollback log from: {log}")
        click.echo()
        
        # Create execution engine
        engine = ExecutionEngine(logger=logger, config=config)
        
        # Load rollback log
        rollback_log = engine.load_rollback_log(log)
        
        # Display rollback log info
        click.echo(f"Rollback log loaded: {rollback_log.log_id}")
        click.echo(f"Original execution: {rollback_log.execution_plan_id}")
        click.echo(f"Executed at: {rollback_log.executed_at.strftime('%Y-%m-%d %H:%M:%S')}")
        click.echo(f"Operations to rollback: {len(rollback_log.operations)}")
        click.echo()
        
        # Display warning
        click.echo("⚠️  ROLLBACK OPERATION - Best-effort restoration")
        click.echo("   This will attempt to move files back to their original locations.")
        click.echo("   Some operations may fail if files have been modified or moved.")
        click.echo()
        
        if not click.confirm("Are you sure you want to proceed with rollback?"):
            click.echo("Rollback cancelled.")
            return
        
        click.echo()
        click.echo(f"Rolling back {len(rollback_log.operations)} operations...")
        click.echo()
        
        # Perform rollback
        results, summary = engine.rollback(rollback_log)
        
        # Display rollback progress
        for i, result in enumerate(results):
            op = result.operation
            if op.operation_type != "no-op":
                status = "✓" if result.success else "✗"
                click.echo(f"  [{i+1}/{len(results)}] {status} Rollback: {op.destination_path.name if op.destination_path else op.source_path.name}")
                if result.error_message:
                    click.echo(f"      Error: {result.error_message}")
        
        # Display rollback summary
        click.echo()
        click.echo("=" * 60)
        click.echo("Rollback Summary")
        click.echo("=" * 60)
        click.echo(f"  Total operations: {summary['total']}")
        click.echo(f"  Successful: {summary['successful']}")
        click.echo(f"  Failed: {summary['failed']}")
        click.echo(f"  Skipped: {summary['skipped']}")
        click.echo()
        
        # Display completion message
        if summary['failed'] > 0:
            click.echo(f"⚠️  Rollback completed with {summary['failed']} failures.")
            click.echo("   Check the log file for details.")
            click.echo("   Some files may not have been restored to their original locations.")
        else:
            click.echo("✓ Rollback completed successfully!")
            click.echo("  All files have been restored to their original locations.")
        
        logger.info(
            f"Rollback completed: "
            f"{summary['successful']} successful, {summary['failed']} failed, {summary['skipped']} skipped"
        )
        
    except FileNotFoundError as e:
        click.echo(f"Error: {e}", err=True)
        logger.error(f"Rollback log not found: {e}")
        sys.exit(1)
    
    except ValueError as e:
        click.echo(f"Error: Invalid rollback log format: {e}", err=True)
        logger.error(f"Invalid rollback log: {e}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error during rollback: {e}", err=True)
        logger.error(f"Rollback failed: {e}", exc_info=True)
        sys.exit(1)


def _fallback_plan_summary(execution_plan) -> str:
    """Build a short plan summary from summary and summary_by_reason when human_summary is empty."""
    s = execution_plan.summary or {}
    by_r = execution_plan.summary_by_reason or {}
    total = s.get("total", len(execution_plan.operations))
    parts = [
        f"计划操作统计：共 {total} 条（move {s.get('move', 0)}，rename {s.get('rename', 0)}，"
        f"quarantine {s.get('quarantine', 0)}，no-op {s.get('no-op', 0)}）"
    ]
    if by_r:
        parts.append("原因分布：" + "；".join(f"{r}: {c}" for r, c in list(by_r.items())[:8]))
    return "\n".join(parts)


@main.group()
@pass_context
def report(ctx: CLIContext):
    """Generate and export reports.
    
    Generate various reports about your video library including inventory,
    completeness analysis, duplicate detection, and summary statistics.
    """
    pass


@report.command('inventory')
@click.option(
    '--format',
    type=click.Choice(['csv', 'json', 'text'], case_sensitive=False),
    default='text',
    help='Output format (default: text)'
)
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('inventory.csv'),
    help='Input inventory CSV file (default: inventory.csv)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=None,
    help='Output file (default: print to console)'
)
@pass_context
def report_inventory(ctx: CLIContext, format: str, input: Path, output: Optional[Path]):
    """Generate inventory report.
    
    Lists all discovered video files with metadata in the specified format.
    
    Example:
    
        vlm report inventory                        # Text format to console
        vlm report inventory --format csv           # CSV format to console
        vlm report inventory --format json --output inventory_report.json
    """
    from vlm.reports import generate_inventory_report
    from vlm.io import load_inventory_csv
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Load inventory from CSV
        click.echo(f"Loading inventory from: {input}")
        
        video_files = load_inventory_csv(input)
        
        click.echo(f"Loaded {len(video_files)} files")
        click.echo()
        
        # Generate report
        click.echo(f"Generating inventory report in {format} format...")
        
        # For text format, use CSV format as the text representation
        report_format = 'csv' if format == 'text' else format
        report_content = generate_inventory_report(video_files, report_format, config.library_root)
        
        # Output report
        if output:
            # Save to file
            output.parent.mkdir(parents=True, exist_ok=True)
            with open(output, 'w', encoding='utf-8') as f:
                f.write(report_content)
            click.echo(f"Report saved to: {output}")
        else:
            # Print to console
            click.echo()
            click.echo(report_content)
        
        logger.info(f"Generated inventory report in {format} format with {len(video_files)} files")
        
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error generating inventory report: {e}", err=True)
        logger.error(f"Inventory report generation failed: {e}", exc_info=True)
        sys.exit(1)


@report.command('completeness')
@click.option(
    '--format',
    type=click.Choice(['text', 'json'], case_sensitive=False),
    default='text',
    help='Output format (default: text)'
)
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('analysis.json'),
    help='Input analysis JSON file (default: analysis.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=None,
    help='Output file (default: print to console)'
)
@click.option(
    '--plan',
    type=click.Path(path_type=Path),
    default=None,
    help='Optional plan JSON; when provided, report includes plan content summary'
)
@pass_context
def report_completeness(ctx: CLIContext, format: str, input: Path, output: Optional[Path], plan: Optional[Path]):
    """Generate completeness report.
    
    Shows series with episode gaps detected through heuristic analysis.
    
    Example:
    
        vlm report completeness                     # Text format to console
        vlm report completeness --format json       # JSON format to console
        vlm report completeness --plan plan.json   # Include plan content summary
        vlm report completeness --format text --output completeness.txt
    """
    from vlm.reports import generate_completeness_report
    from vlm.models import SeasonCompleteness
    from vlm.planner import load_plan
    from vlm.io import load_analysis_json

    config = ctx.config
    logger = ctx.logger

    plan_summary = None
    if plan:
        if not plan.exists():
            click.echo(f"Error: Plan file not found: {plan}", err=True)
            sys.exit(1)
        execution_plan = load_plan(plan)
        plan_summary = execution_plan.human_summary or _fallback_plan_summary(execution_plan)
    
    try:
        # Load analysis from JSON
        click.echo(f"Loading analysis from: {input}")
        
        analysis_data = load_analysis_json(input)
        
        # Extract completeness data
        completeness_list = analysis_data.get('completeness', [])
        
        # Convert to SeasonCompleteness objects
        season_completeness = []
        for c in completeness_list:
            season_completeness.append(SeasonCompleteness(
                series_title=c['series_title'],
                season=c['season'],
                episodes_found=c['episodes_found'],
                episodes_missing=c['episodes_missing']
            ))
        
        click.echo(f"Loaded {len(season_completeness)} series with gaps")
        click.echo()
        
        # Generate report
        click.echo(f"Generating completeness report in {format} format...")
        report_content = generate_completeness_report(
            season_completeness, format, config.library_root, plan_summary=plan_summary
        )
        
        # Output report
        if output:
            # Save to file
            output.parent.mkdir(parents=True, exist_ok=True)
            with open(output, 'w', encoding='utf-8') as f:
                f.write(report_content)
            click.echo(f"Report saved to: {output}")
        else:
            # Print to console
            click.echo()
            click.echo(report_content)
        
        logger.info(f"Generated completeness report in {format} format with {len(season_completeness)} series")
        
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse JSON file: {e}", err=True)
        logger.error(f"JSON parsing failed: {e}", exc_info=True)
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error generating completeness report: {e}", err=True)
        logger.error(f"Completeness report generation failed: {e}", exc_info=True)
        sys.exit(1)


@report.command('duplicates')
@click.option(
    '--format',
    type=click.Choice(['text', 'json'], case_sensitive=False),
    default='text',
    help='Output format (default: text)'
)
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('analysis.json'),
    help='Input analysis JSON file (default: analysis.json)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=None,
    help='Output file (default: print to console)'
)
@click.option(
    '--plan',
    type=click.Path(path_type=Path),
    default=None,
    help='Optional plan JSON; when provided, report includes plan content summary'
)
@pass_context
def report_duplicates(ctx: CLIContext, format: str, input: Path, output: Optional[Path], plan: Optional[Path]):
    """Generate duplicate report.
    
    Shows duplicate files with quality comparison data to help decide which
    files to keep.
    
    Example:
    
        vlm report duplicates                       # Text format to console
        vlm report duplicates --format json         # JSON format to console
        vlm report duplicates --plan plan.json     # Include plan content summary
        vlm report duplicates --format text --output duplicates.txt
    """
    from vlm.reports import generate_duplicate_report
    from vlm.models import DuplicateGroup, MovieIdentity, SeriesIdentity, VideoFile
    from vlm.planner import load_plan
    from datetime import datetime, timezone
    from vlm.io import load_analysis_json
    
    config = ctx.config
    logger = ctx.logger

    plan_summary = None
    if plan:
        if not plan.exists():
            click.echo(f"Error: Plan file not found: {plan}", err=True)
            sys.exit(1)
        execution_plan = load_plan(plan)
        plan_summary = execution_plan.human_summary or _fallback_plan_summary(execution_plan)
    
    try:
        # Load analysis from JSON
        click.echo(f"Loading analysis from: {input}")
        
        analysis_data = load_analysis_json(input)
        
        # Extract duplicates data
        duplicates_list = analysis_data.get('duplicates', [])
        
        # Convert to DuplicateGroup objects
        duplicate_groups = []
        for d in duplicates_list:
            identity_data = d['identity']
            
            # Reconstruct identity
            if identity_data['type'] == 'movie':
                identity = MovieIdentity(
                    title=identity_data['title'],
                    year=identity_data.get('year'),
                    confidence=1.0,
                    needs_review=False,
                    original_filename=""
                )
            else:  # series
                identity = SeriesIdentity(
                    title=identity_data['title'],
                    season=identity_data.get('season'),
                    episodes=identity_data.get('episodes', []),
                    confidence=1.0,
                    needs_review=False,
                    original_filename=""
                )
            
            quality_by_path = {
                str(item.get("path", "")): item for item in d.get("quality_comparison", [])
            }

            # Reconstruct VideoFile objects from file paths and preserve size metadata
            files = []
            for file_path in d['files']:
                quality = quality_by_path.get(str(file_path), {})
                files.append(VideoFile(
                    path=Path(file_path),
                    filename=Path(file_path).name,
                    size_bytes=int(quality.get("size_bytes", 0) or 0),
                    modified_timestamp=datetime.now(timezone.utc),
                    category="",
                    resolution=quality.get("resolution"),
                    codec=quality.get("codec"),
                    duration_seconds=quality.get("duration_seconds"),
                    bitrate_kbps=quality.get("bitrate_kbps"),
                ))
            
            duplicate_groups.append(DuplicateGroup(
                identity=identity,
                files=files,
                quality_comparison=d['quality_comparison']
            ))
        
        click.echo(f"Loaded {len(duplicate_groups)} duplicate groups")
        click.echo()
        
        # Generate report
        click.echo(f"Generating duplicate report in {format} format...")
        report_content = generate_duplicate_report(
            duplicate_groups, format, config.library_root, plan_summary=plan_summary
        )
        
        # Output report
        if output:
            # Save to file
            output.parent.mkdir(parents=True, exist_ok=True)
            with open(output, 'w', encoding='utf-8') as f:
                f.write(report_content)
            click.echo(f"Report saved to: {output}")
        else:
            # Print to console
            click.echo()
            click.echo(report_content)
        
        logger.info(f"Generated duplicate report in {format} format with {len(duplicate_groups)} groups")
        
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    
    except json.JSONDecodeError as e:
        click.echo(f"Error: Failed to parse JSON file: {e}", err=True)
        logger.error(f"JSON parsing failed: {e}", exc_info=True)
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error generating duplicate report: {e}", err=True)
        logger.error(f"Duplicate report generation failed: {e}", exc_info=True)
        sys.exit(1)


@report.command('summary')
@click.option(
    '--input',
    type=click.Path(exists=True, path_type=Path),
    default=Path('inventory.csv'),
    help='Input inventory CSV file (default: inventory.csv)'
)
@click.option(
    '--output',
    type=click.Path(path_type=Path),
    default=None,
    help='Output file (default: print to console)'
)
@pass_context
def report_summary(ctx: CLIContext, input: Path, output: Optional[Path]):
    """Generate summary report.
    
    Shows library statistics including total file count, size, and category
    breakdown.
    
    Example:
    
        vlm report summary                          # Print to console
        vlm report summary --output summary.txt     # Save to file
    """
    from vlm.reports import generate_summary_report
    from vlm.io import load_inventory_csv
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Load inventory from CSV
        click.echo(f"Loading inventory from: {input}")
        
        video_files = load_inventory_csv(input)
        
        click.echo(f"Loaded {len(video_files)} files")
        click.echo()
        
        # Generate report
        click.echo("Generating summary report...")
        report_content = generate_summary_report(video_files, config.library_root)
        
        # Output report
        if output:
            # Save to file
            output.parent.mkdir(parents=True, exist_ok=True)
            with open(output, 'w', encoding='utf-8') as f:
                f.write(report_content)
            click.echo(f"Report saved to: {output}")
        else:
            # Print to console
            click.echo()
            click.echo(report_content)
        
        logger.info(f"Generated summary report with {len(video_files)} files")
        
    except FileNotFoundError:
        click.echo(f"Error: Input file not found: {input}", err=True)
        logger.error(f"Input file not found: {input}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error generating summary report: {e}", err=True)
        logger.error(f"Summary report generation failed: {e}", exc_info=True)
        sys.exit(1)


@main.group()
@pass_context
def state(ctx: CLIContext):
    """Manage file states.
    
    Track file statuses and user decisions throughout the workflow.
    """
    pass


@state.command('show')
@click.argument('file', type=click.Path(path_type=Path))
@pass_context
def state_show(ctx: CLIContext, file: Path):
    """Show state for a file.
    
    Displays the current status, reason, and last update timestamp for a file.
    
    Example:
    
        vlm state show /path/to/movie.mkv
    """
    from vlm.state import StateManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Get state store path
        state_path = Path.home() / ".vlm" / "state.json"
        
        # Create state manager
        manager = StateManager(state_path)
        
        # Get file state
        file_state = manager.get_file_state(file)
        
        if file_state is None:
            click.echo(f"No state found for file: {file}")
            click.echo("This file has not been tracked yet.")
        else:
            click.echo(f"State for file: {file}")
            click.echo()
            click.echo(f"  Status: {file_state.status}")
            if file_state.reason:
                click.echo(f"  Reason: {file_state.reason}")
            click.echo(f"  Updated: {file_state.updated_at.strftime('%Y-%m-%d %H:%M:%S')}")
        
        logger.info(f"Showed state for file: {file}")
        
    except Exception as e:
        click.echo(f"Error showing file state: {e}", err=True)
        logger.error(f"Failed to show file state: {e}", exc_info=True)
        sys.exit(1)


@state.command('set')
@click.argument('file', type=click.Path(path_type=Path))
@click.option(
    '--status',
    type=click.Choice(['reviewed', 'ignored', 'planned', 'executed', 'quarantined'], case_sensitive=False),
    required=True,
    help='Status to set for the file'
)
@click.option(
    '--reason',
    type=str,
    default=None,
    help='Optional reason for the status'
)
@pass_context
def state_set(ctx: CLIContext, file: Path, status: str, reason: Optional[str]):
    """Set state for a file.
    
    Updates the status and optional reason for a file. This operation is
    idempotent - setting the same status multiple times will update the
    timestamp and reason.
    
    Valid statuses: reviewed, ignored, planned, executed, quarantined
    
    Example:
    
        vlm state set /path/to/movie.mkv --status reviewed
        vlm state set /path/to/movie.mkv --status ignored --reason "duplicate"
    """
    from vlm.state import StateManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Get state store path
        state_path = Path.home() / ".vlm" / "state.json"
        
        # Create state manager
        manager = StateManager(state_path)
        
        # Set file state
        manager.set_file_state(file, status, reason)
        
        # Save state
        manager.save()
        
        # Display confirmation
        click.echo(f"✓ State updated for file: {file}")
        click.echo(f"  Status: {status}")
        if reason:
            click.echo(f"  Reason: {reason}")
        
        logger.info(f"Set state for file {file}: status={status}, reason={reason}")
        
    except ValueError as e:
        click.echo(f"Error: {e}", err=True)
        logger.error(f"Invalid status: {e}")
        sys.exit(1)
    
    except Exception as e:
        click.echo(f"Error setting file state: {e}", err=True)
        logger.error(f"Failed to set file state: {e}", exc_info=True)
        sys.exit(1)


@state.command('query')
@click.option(
    '--status',
    type=click.Choice(['reviewed', 'ignored', 'planned', 'executed', 'quarantined'], case_sensitive=False),
    required=True,
    help='Status to query for'
)
@pass_context
def state_query(ctx: CLIContext, status: str):
    """Query files by status.
    
    Lists all files with the specified status.
    
    Example:
    
        vlm state query --status ignored
        vlm state query --status reviewed
    """
    from vlm.state import StateManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Get state store path
        state_path = Path.home() / ".vlm" / "state.json"
        
        # Create state manager
        manager = StateManager(state_path)
        
        # Query files by status
        file_states = manager.query_by_status(status)
        
        if not file_states:
            click.echo(f"No files found with status '{status}'.")
            return
        
        # Display results
        click.echo(f"Files with status '{status}':")
        click.echo("=" * 80)
        click.echo()
        
        for i, file_state in enumerate(file_states, 1):
            click.echo(f"[{i}] {file_state.file_path}")
            if file_state.reason:
                click.echo(f"    Reason: {file_state.reason}")
            click.echo(f"    Updated: {file_state.updated_at.strftime('%Y-%m-%d %H:%M:%S')}")
            click.echo()
        
        click.echo("=" * 80)
        click.echo(f"Total: {len(file_states)} file(s)")
        
        logger.info(f"Queried files with status '{status}': {len(file_states)} found")
        
    except Exception as e:
        click.echo(f"Error querying file states: {e}", err=True)
        logger.error(f"Failed to query file states: {e}", exc_info=True)
        sys.exit(1)


@state.command('clear')
@click.argument('file', type=click.Path(path_type=Path))
@pass_context
def state_clear(ctx: CLIContext, file: Path):
    """Clear state for a file.
    
    Removes the state tracking for a file.
    
    Example:
    
        vlm state clear /path/to/movie.mkv
    """
    from vlm.state import StateManager
    
    config = ctx.config
    logger = ctx.logger
    
    try:
        # Get state store path
        state_path = Path.home() / ".vlm" / "state.json"
        
        # Create state manager
        manager = StateManager(state_path)
        
        # Check if state exists
        file_state = manager.get_file_state(file)
        
        if file_state is None:
            click.echo(f"No state found for file: {file}")
            click.echo("Nothing to clear.")
            return
        
        # Clear file state
        manager.clear_state(file)
        
        # Save state
        manager.save()
        
        # Display confirmation
        click.echo(f"✓ State cleared for file: {file}")
        
        logger.info(f"Cleared state for file: {file}")
        
    except Exception as e:
        click.echo(f"Error clearing file state: {e}", err=True)
        logger.error(f"Failed to clear file state: {e}", exc_info=True)
        sys.exit(1)


@main.group(name='config')
@pass_context
def config_cmd(ctx: CLIContext):
    """Manage configuration.
    
    Initialize, view, and validate configuration settings.
    """
    pass


@config_cmd.command('init')
@click.option(
    '--path',
    type=click.Path(path_type=Path),
    default=default_config_path,
    help='Path where configuration file should be created'
)
@pass_context
def config_init(ctx: CLIContext, path: Path):
    """Initialize configuration file with defaults."""
    try:
        if path.exists():
            click.echo(f"Configuration file already exists at {path}", err=True)
            if not click.confirm("Overwrite existing configuration?"):
                click.echo("Configuration initialization cancelled.")
                return
        
        create_default_config(path)
        click.echo(f"Configuration file created at {path}")
        click.echo("Edit this file to customize your settings.")
        
    except Exception as e:
        click.echo(f"Error creating configuration: {e}", err=True)
        sys.exit(1)


@config_cmd.command('show')
@pass_context
def config_show(ctx: CLIContext):
    """Show current configuration."""
    cfg = ctx.config
    click.echo("Current configuration:")
    click.echo(f"  Library root: {cfg.library_root}")
    click.echo(f"  Video extensions: {', '.join(cfg.video_extensions)}")
    click.echo(f"  Movie template: {cfg.movie_template}")
    click.echo(f"  Series template: {cfg.series_template}")
    click.echo(f"  Movie filename template: {cfg.movie_filename_template}")
    click.echo(f"  Series filename template: {cfg.series_filename_template}")
    click.echo(f"  Quarantine directory: {cfg.quarantine_dir}")
    click.echo(f"  Log level: {cfg.log_level}")


@config_cmd.command('validate')
@pass_context
def config_validate(ctx: CLIContext):
    """Validate configuration."""
    cfg = ctx.config
    errors = validate_config(cfg)
    
    if not errors:
        click.echo("Configuration is valid.")
    else:
        click.echo("Configuration validation errors:", err=True)
        for error in errors:
            click.echo(f"  - {error}", err=True)
        sys.exit(1)


if __name__ == '__main__':
    main()