immich-lib 1.2.0

//! CLI tool for managing Immich duplicates with metadata-aware selection.

mod config;

use std::fs::File;
use std::io::{BufReader, BufWriter, Write};
use std::num::NonZeroU32;
use std::path::PathBuf;

use anyhow::{Context, Result};
use chrono::{DateTime, Utc};
use clap::{Parser, Subcommand};
use governor::{Quota, RateLimiter};
use indicatif::{ProgressBar, ProgressStyle};
use serde::{Deserialize, Serialize};

use immich_lib::models::ExecutionConfig;
use immich_lib::testing::{all_fixtures, detect_scenarios, format_report, generate_image, ScenarioReport};
use immich_lib::{DuplicateAnalysis, Executor, ImmichClient, LetterboxAnalysis};

/// Immich duplicate manager - prioritizes metadata completeness over file size
#[derive(Parser, Debug)]
#[command(name = "immich-dupes")]
#[command(version, about, long_about = None)]
struct Args {
    /// Immich server URL (not required for generate-fixtures)
    #[arg(short, long, env = "IMMICH_URL", required = false)]
    url: Option<String>,

    /// API key for authentication (not required for generate-fixtures)
    #[arg(short, long, env = "IMMICH_API_KEY", required = false)]
    api_key: Option<String>,

    /// Save credentials to config file after successful connection
    #[arg(long, global = true)]
    save: bool,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Analyze duplicates and output results to JSON
    Analyze {
        /// Output file path for JSON results
        #[arg(short, long)]
        output: PathBuf,
    },

    /// Execute duplicate removal based on analysis JSON
    Execute {
        /// Path to analysis JSON from analyze command
        #[arg(short, long)]
        input: PathBuf,

        /// Directory to download backup files to
        #[arg(short, long)]
        backup_dir: PathBuf,

        /// Permanently delete instead of moving to trash
        #[arg(long, default_value = "false")]
        force: bool,

        /// Max requests per second (default: 10)
        #[arg(long, default_value = "10")]
        rate_limit: u32,

        /// Max concurrent operations (default: 5)
        #[arg(long, default_value = "5")]
        concurrent: usize,

        /// Skip groups that need manual review
        #[arg(long, default_value = "false")]
        skip_review: bool,

        /// Skip confirmation prompt
        #[arg(short, long, default_value = "false")]
        yes: bool,
    },

    /// Verify post-execution state: check winners exist, losers deleted
    Verify {
        /// Path to the analysis JSON that was used for execution
        analysis_json: PathBuf,

        /// Output format (text or json)
        #[arg(long, default_value = "text")]
        format: String,
    },

    /// Find test candidates by scanning duplicate groups and categorizing by scenario
    FindTestCandidates {
        /// Output format (text or json)
        #[arg(long, default_value = "text")]
        format: String,

        /// Only show groups matching specific scenario prefix (e.g., "W1", "C", "F")
        #[arg(long)]
        scenario: Option<String>,

        /// Output file (stdout if not specified)
        #[arg(short, long)]
        output: Option<PathBuf>,
    },

    /// Generate synthetic test fixtures
    GenerateFixtures {
        /// Output directory for fixtures
        #[arg(long, default_value = "tests/fixtures")]
        output_dir: PathBuf,

        /// Only generate specific scenario (e.g., "W1", "C3")
        #[arg(long)]
        scenario: Option<String>,
    },

    /// Restore backed-up files by uploading them to Immich
    Restore {
        /// Directory containing backup files from execute command
        #[arg(short, long)]
        backup_dir: PathBuf,

        /// Preview what would be restored without uploading
        #[arg(long, default_value = "false")]
        dry_run: bool,
    },

    /// Letterbox duplicate management (iPhone 4:3/16:9 pairs)
    Letterbox {
        #[command(subcommand)]
        command: LetterboxCommands,
    },
}

#[derive(Subcommand, Debug)]
enum LetterboxCommands {
    /// Analyze all assets for letterbox pairs and output results to JSON
    Analyze {
        /// Output file path for JSON results
        #[arg(short, long)]
        output: PathBuf,
    },

    /// Execute letterbox removal: download 16:9 backups then delete
    Execute {
        /// Path to letterbox analysis JSON from analyze command
        #[arg(short, long)]
        input: PathBuf,

        /// Directory to download backup files to
        #[arg(short, long)]
        backup_dir: PathBuf,

        /// Permanently delete instead of moving to trash
        #[arg(long, default_value = "false")]
        force: bool,

        /// Max requests per second (default: 10)
        #[arg(long, default_value = "10")]
        rate_limit: u32,

        /// Skip confirmation prompt
        #[arg(short, long, default_value = "false")]
        yes: bool,
    },

    /// Verify post-execution state: check keepers exist, deletes removed
    Verify {
        /// Path to the letterbox analysis JSON that was used for execution
        analysis_json: PathBuf,

        /// Output format (text or json)
        #[arg(long, default_value = "text")]
        format: String,
    },
}

/// Report containing analysis results for all duplicate groups.
#[derive(Debug, Serialize, Deserialize)]
struct AnalysisReport {
    /// Timestamp when the analysis was generated
    generated_at: DateTime<Utc>,

    /// The Immich server URL that was analyzed
    server_url: String,

    /// Total number of duplicate groups found
    total_groups: usize,

    /// Total number of assets across all groups
    total_assets: usize,

    /// Number of groups that need manual review due to conflicts
    needs_review_count: usize,

    /// Analysis results for each duplicate group
    groups: Vec<DuplicateAnalysis>,
}

/// Result of verifying a single group
#[derive(Debug, Serialize)]
struct GroupVerification {
    /// Duplicate group ID
    duplicate_id: String,

    /// Winner verification status
    winner_status: AssetStatus,

    /// Loser verification statuses
    loser_statuses: Vec<AssetStatus>,

    /// Consolidation checks (GPS transferred, etc.)
    consolidation_checks: Vec<ConsolidationCheck>,
}

/// Status of a single asset in verification
#[derive(Debug, Serialize)]
struct AssetStatus {
    asset_id: String,
    filename: String,
    /// "present", "deleted", "error"
    status: String,
    /// Optional error message
    error: Option<String>,
}

/// A consolidation check result
#[derive(Debug, Serialize)]
struct ConsolidationCheck {
    /// What was checked (e.g., "gps_transferred", "datetime_transferred")
    check_type: String,
    /// Whether the check passed
    passed: bool,
    /// Details about the check
    details: String,
}

/// Full verification report
#[derive(Debug, Serialize)]
struct VerificationReport {
    /// When verification was performed
    verified_at: DateTime<Utc>,

    /// Server URL
    server_url: String,

    /// Groups verified
    groups_verified: usize,

    /// Winners present count
    winners_present: usize,

    /// Winners missing count (errors)
    winners_missing: usize,

    /// Losers confirmed deleted
    losers_deleted: usize,

    /// Losers still present (errors)
    losers_still_present: usize,

    /// Consolidation checks passed
    consolidation_passed: usize,

    /// Consolidation checks failed
    consolidation_failed: usize,

    /// Per-group verification results
    groups: Vec<GroupVerification>,

    /// Any anomalies detected
    anomalies: Vec<String>,
}

/// Resolves credentials from CLI args, config file, or interactive prompt.
///
/// Priority: CLI args (which include env vars via clap) > config file > interactive prompt
///
/// Returns: (url, api_key, was_prompted)
/// The `was_prompted` flag indicates if credentials were obtained via interactive prompt.
fn resolve_credentials(
    cli_url: Option<&str>,
    cli_api_key: Option<&str>,
    config: &config::Config,
) -> Result<(String, String, bool)> {
    // Try CLI/env first
    if let (Some(url), Some(key)) = (cli_url, cli_api_key) {
        return Ok((url.to_string(), key.to_string(), false));
    }

    // Try config file
    if let (Some(url), Some(key)) = (&config.server.url, &config.server.api_key) {
        return Ok((url.clone(), key.clone(), false));
    }

    // Prompt interactively
    let (url, key) = config::prompt_credentials()?;
    Ok((url, key, true))
}

/// Offers to save credentials to config file if prompted or --save flag used.
///
/// Returns Ok(true) if saved, Ok(false) if not saved (user declined or already saved).
fn maybe_save_credentials(
    url: &str,
    api_key: &str,
    was_prompted: bool,
    save_flag: bool,
    config: &config::Config,
) -> Result<bool> {
    // Only offer to save if prompted or --save flag
    if !was_prompted && !save_flag {
        return Ok(false);
    }

    let config_path = config::config_path();

    // Check if already saved (config has these exact values)
    if config.server.url.as_deref() == Some(url)
        && config.server.api_key.as_deref() == Some(api_key)
    {
        return Ok(false);
    }

    // Ask user if they want to save
    if config::prompt_save(&config_path) {
        let mut new_config = config.clone();
        new_config.server.url = Some(url.to_string());
        new_config.server.api_key = Some(api_key.to_string());
        config::save(&new_config)?;
        println!("Credentials saved to {}", config_path.display());
        return Ok(true);
    }

    Ok(false)
}

#[tokio::main]
async fn main() -> Result<()> {
    // Load .env file if present
    let _ = dotenvy::dotenv();

    // Load config file
    let config = config::load();

    let args = Args::parse();

    match args.command {
        Commands::Analyze { output } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            run_analyze(&url, &api_key, &output).await?;
            // Offer to save after successful command
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
        Commands::Execute {
            input,
            backup_dir,
            force,
            rate_limit,
            concurrent,
            skip_review,
            yes,
        } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            run_execute(
                &url,
                &api_key,
                &input,
                &backup_dir,
                force,
                rate_limit,
                concurrent,
                skip_review,
                yes,
            )
            .await?;
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
        Commands::Verify { analysis_json, format } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            run_verify(&url, &api_key, &analysis_json, &format).await?;
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
        Commands::FindTestCandidates {
            format,
            scenario,
            output,
        } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            run_find_test_candidates(&url, &api_key, &format, scenario.as_deref(), output.as_ref())
                .await?;
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
        Commands::GenerateFixtures { output_dir, scenario } => {
            run_generate_fixtures(&output_dir, scenario.as_deref())?;
        }
        Commands::Restore { backup_dir, dry_run } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            run_restore(&url, &api_key, &backup_dir, dry_run).await?;
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
        Commands::Letterbox { command } => {
            let (url, api_key, prompted) = resolve_credentials(
                args.url.as_deref(),
                args.api_key.as_deref(),
                &config,
            )?;
            match command {
                LetterboxCommands::Analyze { output } => {
                    run_letterbox_analyze(&url, &api_key, &output).await?;
                }
                LetterboxCommands::Execute {
                    input,
                    backup_dir,
                    force,
                    rate_limit,
                    yes,
                } => {
                    run_letterbox_execute(&url, &api_key, &input, &backup_dir, force, rate_limit, yes).await?;
                }
                LetterboxCommands::Verify { analysis_json, format } => {
                    run_letterbox_verify(&url, &api_key, &analysis_json, &format).await?;
                }
            }
            maybe_save_credentials(&url, &api_key, prompted, args.save, &config)?;
        }
    }

    Ok(())
}

async fn run_analyze(url: &str, api_key: &str, output: &PathBuf) -> Result<()> {
    println!("Connecting to Immich server at {}...", url);

    // Create client
    let client =
        ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    // Fetch duplicates
    println!("Fetching duplicate groups...");
    let duplicates = client
        .get_duplicates()
        .await
        .context("Failed to fetch duplicates from Immich")?;

    // Analyze each group
    println!("Analyzing {} duplicate groups...", duplicates.len());
    let groups: Vec<DuplicateAnalysis> = duplicates
        .iter()
        .map(DuplicateAnalysis::from_group)
        .collect();

    // Calculate statistics
    let total_groups = groups.len();
    let total_assets: usize = groups
        .iter()
        .map(|g| 1 + g.losers.len()) // winner + losers
        .sum();
    let needs_review_count = groups.iter().filter(|g| g.needs_review).count();

    // Create report
    let report = AnalysisReport {
        generated_at: Utc::now(),
        server_url: url.to_string(),
        total_groups,
        total_assets,
        needs_review_count,
        groups,
    };

    // Write JSON to file
    let file = File::create(output)
        .with_context(|| format!("Failed to create output file: {}", output.display()))?;
    let writer = BufWriter::new(file);
    serde_json::to_writer_pretty(writer, &report)
        .context("Failed to write JSON output")?;

    // Print summary
    println!();
    println!("Analysis complete!");
    println!();
    println!("Duplicate groups: {}", total_groups);
    println!("Total assets: {}", total_assets);
    if needs_review_count > 0 {
        println!(
            "Groups needing review: {} (have metadata conflicts)",
            needs_review_count
        );
    } else {
        println!("Groups needing review: 0");
    }
    println!();
    println!("Output written to: {}", output.display());

    Ok(())
}

#[allow(clippy::too_many_arguments)]
async fn run_execute(
    url: &str,
    api_key: &str,
    input: &PathBuf,
    backup_dir: &PathBuf,
    force: bool,
    rate_limit: u32,
    concurrent: usize,
    skip_review: bool,
    yes: bool,
) -> Result<()> {
    // Read and parse analysis JSON
    let file = File::open(input)
        .with_context(|| format!("Failed to open input file: {}", input.display()))?;
    let reader = BufReader::new(file);
    let report: AnalysisReport = serde_json::from_reader(reader)
        .context("Failed to parse analysis JSON")?;

    // Filter groups based on skip_review flag
    let groups: Vec<DuplicateAnalysis> = if skip_review {
        report.groups.into_iter().filter(|g| !g.needs_review).collect()
    } else {
        report.groups
    };

    if groups.is_empty() {
        println!("No groups to process.");
        return Ok(());
    }

    // Calculate assets to process
    let total_assets: usize = groups.iter().map(|g| g.losers.len()).sum();
    let estimated_size: u64 = groups
        .iter()
        .flat_map(|g| g.losers.iter())
        .filter_map(|l| l.file_size)
        .sum();

    // Create backup directory if it doesn't exist
    std::fs::create_dir_all(backup_dir)
        .with_context(|| format!("Failed to create backup directory: {}", backup_dir.display()))?;

    // Print execution summary
    println!();
    println!("Execution Plan");
    println!("==============");
    println!("Groups to process: {}", groups.len());
    println!("Assets to download: {}", total_assets);
    if estimated_size > 0 {
        let size_mb = estimated_size as f64 / 1_048_576.0;
        println!("Estimated disk space: {:.1} MB", size_mb);
    }
    println!("Backup directory: {}", backup_dir.display());
    println!("Force delete: {}", if force { "yes (permanent)" } else { "no (trash)" });
    println!();

    // Confirmation prompt
    if !yes {
        print!("About to download {} assets and delete them from Immich. Continue? [y/N] ", total_assets);
        std::io::stdout().flush()?;

        let mut response = String::new();
        std::io::stdin().read_line(&mut response)?;
        let response = response.trim().to_lowercase();

        if response != "y" && response != "yes" {
            println!("Aborted.");
            return Ok(());
        }
    }

    println!();
    println!("Starting execution...");
    println!();

    // Create client and executor
    let client = ImmichClient::new(url, api_key)
        .context("Failed to create Immich client")?;

    let config = ExecutionConfig {
        requests_per_sec: rate_limit,
        max_concurrent: concurrent,
        backup_dir: backup_dir.clone(),
        force_delete: force,
    };

    let executor = Executor::new(client, config);

    // Execute
    let exec_report = executor.execute_all(&groups).await;

    // Print summary
    println!();
    println!("Execution Complete");
    println!("==================");
    println!("Groups processed: {}", exec_report.total_groups);
    println!("Assets downloaded: {}", exec_report.downloaded);
    println!("Assets deleted: {}", exec_report.deleted);
    println!("Failed operations: {}", exec_report.failed);
    println!("Skipped: {}", exec_report.skipped);

    // Show first few errors if any
    if exec_report.failed > 0 {
        println!();
        println!("First errors:");
        let errors: Vec<_> = exec_report
            .results
            .iter()
            .flat_map(|g| g.download_results.iter())
            .filter_map(|r| {
                if let immich_lib::models::OperationResult::Failed { id, error } = r {
                    Some((id, error))
                } else {
                    None
                }
            })
            .take(5)
            .collect();

        for (id, error) in errors {
            println!("  - {}: {}", id, error);
        }
    }

    // Write execution report to backup directory
    let timestamp = Utc::now().format("%Y%m%d-%H%M%S");
    let report_path = backup_dir.join(format!("execution-report-{}.json", timestamp));
    let report_file = File::create(&report_path)
        .with_context(|| format!("Failed to create report file: {}", report_path.display()))?;
    let writer = BufWriter::new(report_file);
    serde_json::to_writer_pretty(writer, &exec_report)
        .context("Failed to write execution report")?;

    println!();
    println!("Execution report: {}", report_path.display());

    Ok(())
}

async fn run_verify(url: &str, api_key: &str, analysis_json: &PathBuf, format: &str) -> Result<()> {
    println!("Verifying post-execution state...");
    println!("Analysis file: {}", analysis_json.display());
    println!();

    // Load analysis JSON
    let file = File::open(analysis_json)
        .with_context(|| format!("Failed to open analysis file: {}", analysis_json.display()))?;
    let reader = BufReader::new(file);
    let analysis: AnalysisReport = serde_json::from_reader(reader)
        .context("Failed to parse analysis JSON")?;

    // Create client
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    let mut groups_verified = 0;
    let mut winners_present = 0;
    let mut winners_missing = 0;
    let mut losers_deleted = 0;
    let mut losers_still_present = 0;
    let mut consolidation_passed = 0;
    let mut consolidation_failed = 0;
    let mut group_results = Vec::new();
    let mut anomalies = Vec::new();

    println!("Checking {} groups...", analysis.groups.len());
    println!();

    for group in &analysis.groups {
        groups_verified += 1;

        // Check winner exists
        let winner_status = match client.get_asset(&group.winner.asset_id).await {
            Ok(asset) => {
                winners_present += 1;
                // Winner is present - check for consolidation if needed
                let mut consolidation_checks = Vec::new();

                // Check if any loser had GPS and winner didn't originally have it
                let winner_had_gps = group.winner.score.gps > 0;
                let any_loser_had_gps = group.losers.iter().any(|l| l.score.gps > 0);

                if !winner_had_gps && any_loser_had_gps {
                    // GPS should have been consolidated from loser to winner
                    let has_gps_now = asset.exif_info.as_ref().is_some_and(|e| e.has_gps());
                    if has_gps_now {
                        consolidation_passed += 1;
                        consolidation_checks.push(ConsolidationCheck {
                            check_type: "gps_transferred".to_string(),
                            passed: true,
                            details: "GPS coordinates successfully transferred from loser".to_string(),
                        });
                    } else {
                        consolidation_failed += 1;
                        consolidation_checks.push(ConsolidationCheck {
                            check_type: "gps_transferred".to_string(),
                            passed: false,
                            details: "GPS coordinates were NOT transferred from loser".to_string(),
                        });
                        anomalies.push(format!(
                            "Group {}: GPS not transferred to winner {}",
                            group.duplicate_id, group.winner.asset_id
                        ));
                    }
                }

                AssetStatus {
                    asset_id: group.winner.asset_id.clone(),
                    filename: group.winner.filename.clone(),
                    status: "present".to_string(),
                    error: None,
                }
            }
            Err(immich_lib::ImmichError::Api { status: 404, .. }) => {
                winners_missing += 1;
                anomalies.push(format!(
                    "CRITICAL: Winner {} ({}) was deleted!",
                    group.winner.asset_id, group.winner.filename
                ));
                AssetStatus {
                    asset_id: group.winner.asset_id.clone(),
                    filename: group.winner.filename.clone(),
                    status: "deleted".to_string(),
                    error: Some("Winner was incorrectly deleted".to_string()),
                }
            }
            Err(e) => {
                winners_missing += 1;
                anomalies.push(format!(
                    "Error checking winner {}: {}",
                    group.winner.asset_id, e
                ));
                AssetStatus {
                    asset_id: group.winner.asset_id.clone(),
                    filename: group.winner.filename.clone(),
                    status: "error".to_string(),
                    error: Some(e.to_string()),
                }
            }
        };

        // Check all losers are deleted (or trashed)
        let mut loser_statuses = Vec::new();
        for loser in &group.losers {
            let loser_status = match client.get_asset(&loser.asset_id).await {
                Ok(asset) => {
                    if asset.is_trashed {
                        // Loser is in trash - this counts as deleted
                        losers_deleted += 1;
                        AssetStatus {
                            asset_id: loser.asset_id.clone(),
                            filename: loser.filename.clone(),
                            status: "trashed".to_string(),
                            error: None,
                        }
                    } else {
                        // Loser still exists and not trashed - this is wrong!
                        losers_still_present += 1;
                        anomalies.push(format!(
                            "Loser {} ({}) still exists (not trashed), should be deleted",
                            loser.asset_id, loser.filename
                        ));
                        AssetStatus {
                            asset_id: loser.asset_id.clone(),
                            filename: loser.filename.clone(),
                            status: "present".to_string(),
                            error: Some("Loser should have been deleted".to_string()),
                        }
                    }
                }
                Err(immich_lib::ImmichError::Api { status: 404, .. }) => {
                    // Loser correctly deleted (permanently)
                    losers_deleted += 1;
                    AssetStatus {
                        asset_id: loser.asset_id.clone(),
                        filename: loser.filename.clone(),
                        status: "deleted".to_string(),
                        error: None,
                    }
                }
                Err(e) => {
                    // Some other error
                    anomalies.push(format!(
                        "Error checking loser {}: {}",
                        loser.asset_id, e
                    ));
                    AssetStatus {
                        asset_id: loser.asset_id.clone(),
                        filename: loser.filename.clone(),
                        status: "error".to_string(),
                        error: Some(e.to_string()),
                    }
                }
            };
            loser_statuses.push(loser_status);
        }

        // Collect consolidation checks from winner verification
        let consolidation_checks = if winner_status.status == "present" {
            let mut checks = Vec::new();
            let winner_had_gps = group.winner.score.gps > 0;
            let any_loser_had_gps = group.losers.iter().any(|l| l.score.gps > 0);
            if !winner_had_gps && any_loser_had_gps {
                // Already tracked above in the winner check
            } else if winner_had_gps {
                checks.push(ConsolidationCheck {
                    check_type: "gps_retained".to_string(),
                    passed: true,
                    details: "Winner already had GPS, no transfer needed".to_string(),
                });
            } else {
                checks.push(ConsolidationCheck {
                    check_type: "no_gps".to_string(),
                    passed: true,
                    details: "No GPS in group, no transfer needed".to_string(),
                });
            }
            checks
        } else {
            Vec::new()
        };

        group_results.push(GroupVerification {
            duplicate_id: group.duplicate_id.clone(),
            winner_status,
            loser_statuses,
            consolidation_checks,
        });

        // Progress indicator
        if groups_verified % 10 == 0 {
            print!(".");
            std::io::stdout().flush()?;
        }
    }
    println!();
    println!();

    // Build report
    let report = VerificationReport {
        verified_at: Utc::now(),
        server_url: url.to_string(),
        groups_verified,
        winners_present,
        winners_missing,
        losers_deleted,
        losers_still_present,
        consolidation_passed,
        consolidation_failed,
        groups: group_results,
        anomalies: anomalies.clone(),
    };

    // Output based on format
    match format.to_lowercase().as_str() {
        "json" => {
            println!("{}", serde_json::to_string_pretty(&report)?);
        }
        _ => {
            println!("Verification Report");
            println!("==================");
            println!();
            println!("Groups verified:       {}", groups_verified);
            println!("Winners present:       {}/{}", winners_present, groups_verified);
            println!("Winners missing:       {}", winners_missing);
            println!("Losers deleted:        {}", losers_deleted);
            println!("Losers still present:  {}", losers_still_present);
            println!();
            println!("Consolidation passed:  {}", consolidation_passed);
            println!("Consolidation failed:  {}", consolidation_failed);

            if !anomalies.is_empty() {
                println!();
                println!("Anomalies ({}):", anomalies.len());
                for anomaly in &anomalies {
                    println!("  - {}", anomaly);
                }
            }

            println!();
            if winners_missing == 0 && losers_still_present == 0 && consolidation_failed == 0 {
                println!("VERIFICATION PASSED: All checks successful");
            } else {
                println!("VERIFICATION FAILED: Issues detected");
            }
        }
    }

    Ok(())
}

async fn run_find_test_candidates(
    url: &str,
    api_key: &str,
    format: &str,
    scenario_filter: Option<&str>,
    output: Option<&PathBuf>,
) -> Result<()> {
    println!("Connecting to Immich server at {}...", url);

    // Create client
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    // Fetch duplicates
    println!("Fetching duplicate groups...");
    let duplicates = client
        .get_duplicates()
        .await
        .context("Failed to fetch duplicates from Immich")?;

    println!("Analyzing {} duplicate groups for test scenarios...", duplicates.len());

    // Detect scenarios for each group
    let mut all_matches = Vec::new();
    for group in &duplicates {
        let matches = detect_scenarios(group);
        all_matches.extend(matches);
    }

    // Filter by scenario prefix if specified
    let filtered_matches = if let Some(prefix) = scenario_filter {
        let prefix_upper = prefix.to_uppercase();
        all_matches
            .into_iter()
            .filter(|m| m.scenario.to_string().to_uppercase().starts_with(&prefix_upper))
            .collect()
    } else {
        all_matches
    };

    // Build report
    let report = ScenarioReport::from_matches(filtered_matches, duplicates.len());

    // Format output
    let output_text = match format.to_lowercase().as_str() {
        "json" => serde_json::to_string_pretty(&report)?,
        _ => format_report(&report),
    };

    // Write output
    if let Some(output_path) = output {
        let mut file = File::create(output_path)
            .with_context(|| format!("Failed to create output file: {}", output_path.display()))?;
        file.write_all(output_text.as_bytes())?;
        println!("\nOutput written to: {}", output_path.display());
    } else {
        println!();
        println!("{}", output_text);
    }

    Ok(())
}

/// Manifest file structure for each scenario fixture
#[derive(Debug, Serialize)]
struct FixtureManifest {
    scenario: String,
    description: String,
    images: Vec<String>,
    expected_winner: String,
}

fn run_generate_fixtures(output_dir: &PathBuf, scenario_filter: Option<&str>) -> Result<()> {
    println!("Loading fixture definitions...");

    let fixtures = all_fixtures();
    let total = fixtures.len();

    // Base images directory (contains real photos for transforms)
    let base_dir = output_dir.join("base");
    if !base_dir.exists() {
        println!("Warning: Base images directory not found: {}", base_dir.display());
        println!("Run the fixture setup first to download base images.");
    }

    // Filter fixtures if scenario specified
    let fixtures: Vec<_> = if let Some(filter) = scenario_filter {
        let filter_upper = filter.to_uppercase();
        fixtures
            .into_iter()
            .filter(|f| f.scenario.to_string().to_uppercase().starts_with(&filter_upper))
            .collect()
    } else {
        fixtures
    };

    if fixtures.is_empty() {
        if let Some(filter) = scenario_filter {
            println!("No fixtures found matching filter: {}", filter);
        } else {
            println!("No fixtures defined.");
        }
        return Ok(());
    }

    println!(
        "Generating {} of {} fixtures...",
        fixtures.len(),
        total
    );

    // Create output directory if it doesn't exist
    std::fs::create_dir_all(output_dir)
        .with_context(|| format!("Failed to create output directory: {}", output_dir.display()))?;

    let mut generated_count = 0;
    let mut failed_count = 0;

    for fixture in &fixtures {
        let scenario_code = fixture.scenario.code();
        let scenario_dir = output_dir.join(scenario_code);

        // Create scenario subdirectory
        std::fs::create_dir_all(&scenario_dir).with_context(|| {
            format!(
                "Failed to create scenario directory: {}",
                scenario_dir.display()
            )
        })?;

        println!("  {} - {}...", scenario_code.to_uppercase(), fixture.description);

        let mut image_filenames = Vec::new();
        let mut all_success = true;

        for image in &fixture.images {
            match generate_image(image, &base_dir, &scenario_dir) {
                Ok(path) => {
                    image_filenames.push(image.filename.clone());
                    println!("    ✓ {}", path.file_name().unwrap_or_default().to_string_lossy());
                }
                Err(e) => {
                    eprintln!("    ✗ {} - {}", image.filename, e);
                    all_success = false;
                }
            }
        }

        // Write manifest
        let manifest = FixtureManifest {
            scenario: scenario_code.to_uppercase(),
            description: fixture.description.clone(),
            images: image_filenames.clone(),
            expected_winner: fixture
                .images
                .get(fixture.expected_winner_index)
                .map(|i| i.filename.clone())
                .unwrap_or_default(),
        };

        let manifest_path = scenario_dir.join("manifest.json");
        let manifest_file = File::create(&manifest_path)
            .with_context(|| format!("Failed to create manifest: {}", manifest_path.display()))?;
        serde_json::to_writer_pretty(manifest_file, &manifest)
            .context("Failed to write manifest JSON")?;

        if all_success {
            generated_count += 1;
        } else {
            failed_count += 1;
        }
    }

    println!();
    println!("Generation complete!");
    println!("  Successful: {}", generated_count);
    if failed_count > 0 {
        println!("  Failed: {}", failed_count);
    }
    println!("  Output directory: {}", output_dir.display());

    Ok(())
}

/// Known media file extensions for filtering backup directory
const MEDIA_EXTENSIONS: &[&str] = &[
    "jpg", "jpeg", "png", "gif", "webp", "heic", "heif", "bmp", "tiff", "tif", "raw",
    "mp4", "mov", "avi", "webm", "mkv", "m4v", "wmv", "flv", "3gp",
];

async fn run_restore(url: &str, api_key: &str, backup_dir: &PathBuf, dry_run: bool) -> Result<()> {
    println!("Restoring from: {}", backup_dir.display());
    println!();

    // Scan backup directory for media files
    let entries = std::fs::read_dir(backup_dir)
        .with_context(|| format!("Failed to read backup directory: {}", backup_dir.display()))?;

    let mut media_files: Vec<PathBuf> = Vec::new();
    for entry in entries {
        let entry = entry?;
        let path = entry.path();

        // Skip directories and non-media files
        if path.is_dir() {
            continue;
        }

        if let Some(ext) = path.extension().and_then(|e| e.to_str())
            && MEDIA_EXTENSIONS.contains(&ext.to_lowercase().as_str())
        {
            media_files.push(path);
        }
    }

    if media_files.is_empty() {
        println!("No media files found in backup directory.");
        return Ok(());
    }

    // Sort for consistent ordering
    media_files.sort();

    println!("Found {} files to restore", media_files.len());
    println!();

    if dry_run {
        println!("DRY RUN - No files will be uploaded");
        println!();
        for (i, path) in media_files.iter().enumerate() {
            let filename = path.file_name().unwrap_or_default().to_string_lossy();
            println!("[{}/{}] Would restore: {}", i + 1, media_files.len(), filename);
        }
        println!();
        println!("Dry run complete: {} files would be restored", media_files.len());
        return Ok(());
    }

    // Create client and upload files
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    let mut success_count = 0;
    let mut failure_count = 0;
    let total = media_files.len();

    for (i, path) in media_files.iter().enumerate() {
        let filename = path.file_name().unwrap_or_default().to_string_lossy();
        print!("[{}/{}] Uploading {}... ", i + 1, total, filename);
        std::io::stdout().flush()?;

        match client.upload_asset(path).await {
            Ok(response) => {
                success_count += 1;
                if response.duplicate {
                    println!("OK (duplicate detected)");
                } else {
                    println!("OK (id: {})", response.id);
                }
            }
            Err(e) => {
                failure_count += 1;
                println!("FAILED: {}", e);
            }
        }
    }

    println!();
    println!("Restore complete: {} uploaded, {} failed", success_count, failure_count);

    if failure_count > 0 {
        println!();
        println!("WARNING: {} files failed to upload. Check errors above.", failure_count);
    }

    Ok(())
}

async fn run_letterbox_analyze(url: &str, api_key: &str, output: &PathBuf) -> Result<()> {
    println!("Connecting to Immich server at {}...", url);

    // Create client
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    // Fetch all assets with pagination
    println!("Fetching all assets...");
    let assets = client
        .get_all_assets()
        .await
        .context("Failed to fetch assets from Immich")?;

    println!("Analyzing {} assets for letterbox pairs...", assets.len());

    // Run letterbox analysis
    let analysis = LetterboxAnalysis::from_assets(&assets);

    // Write JSON to file
    let file = File::create(output)
        .with_context(|| format!("Failed to create output file: {}", output.display()))?;
    let writer = BufWriter::new(file);
    serde_json::to_writer_pretty(writer, &analysis)
        .context("Failed to write JSON output")?;

    // Print summary
    println!();
    println!("Letterbox Analysis Complete!");
    println!();
    println!("Pairs found:          {}", analysis.total_pairs);
    println!("Space recoverable:    {:.2} MB", analysis.total_space_recoverable as f64 / 1_048_576.0);
    println!("Skipped (non-iPhone): {}", analysis.skipped_non_iphone);
    println!("Skipped (ambiguous):  {}", analysis.skipped_ambiguous);
    println!();
    println!("Output written to: {}", output.display());

    Ok(())
}

/// Verification result for a letterbox pair
#[derive(Debug, Serialize)]
struct LetterboxPairVerification {
    /// Shared capture timestamp
    timestamp: String,
    /// Status of the keeper (4:3) asset
    keeper_status: AssetStatus,
    /// Status of the delete (16:9) asset
    delete_status: AssetStatus,
}

/// Full verification report for letterbox execution
#[derive(Debug, Serialize)]
struct LetterboxVerificationReport {
    /// When verification was performed
    verified_at: DateTime<Utc>,
    /// Server URL
    server_url: String,
    /// Total pairs verified
    pairs_verified: usize,
    /// Keepers confirmed present
    keepers_present: usize,
    /// Keepers missing (should not happen)
    keepers_missing: usize,
    /// Deletes confirmed removed (404 or trashed)
    deletes_removed: usize,
    /// Deletes still present (should not happen after execute)
    deletes_still_present: usize,
    /// Per-pair verification results
    pairs: Vec<LetterboxPairVerification>,
    /// Any anomalies detected
    anomalies: Vec<String>,
}

async fn run_letterbox_verify(url: &str, api_key: &str, analysis_json: &PathBuf, format: &str) -> Result<()> {
    println!("Verifying letterbox post-execution state...");
    println!("Analysis file: {}", analysis_json.display());
    println!();

    // Load letterbox analysis JSON
    let file = File::open(analysis_json)
        .with_context(|| format!("Failed to open analysis file: {}", analysis_json.display()))?;
    let reader = BufReader::new(file);
    let analysis: LetterboxAnalysis = serde_json::from_reader(reader)
        .context("Failed to parse letterbox analysis JSON")?;

    // Create client
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    let mut pairs_verified = 0;
    let mut keepers_present = 0;
    let mut keepers_missing = 0;
    let mut deletes_removed = 0;
    let mut deletes_still_present = 0;
    let mut pair_results = Vec::new();
    let mut anomalies = Vec::new();

    println!("Checking {} pairs...", analysis.pairs.len());
    println!();

    for pair in &analysis.pairs {
        pairs_verified += 1;

        // Check keeper exists
        let keeper_status = match client.get_asset(&pair.keeper.id).await {
            Ok(_asset) => {
                keepers_present += 1;
                AssetStatus {
                    asset_id: pair.keeper.id.clone(),
                    filename: pair.keeper.original_file_name.clone(),
                    status: "present".to_string(),
                    error: None,
                }
            }
            Err(immich_lib::ImmichError::Api { status: 404, .. }) => {
                keepers_missing += 1;
                anomalies.push(format!(
                    "CRITICAL: Keeper {} ({}) was deleted!",
                    pair.keeper.id, pair.keeper.original_file_name
                ));
                AssetStatus {
                    asset_id: pair.keeper.id.clone(),
                    filename: pair.keeper.original_file_name.clone(),
                    status: "deleted".to_string(),
                    error: Some("Keeper was incorrectly deleted".to_string()),
                }
            }
            Err(e) => {
                keepers_missing += 1;
                anomalies.push(format!(
                    "Error checking keeper {}: {}",
                    pair.keeper.id, e
                ));
                AssetStatus {
                    asset_id: pair.keeper.id.clone(),
                    filename: pair.keeper.original_file_name.clone(),
                    status: "error".to_string(),
                    error: Some(e.to_string()),
                }
            }
        };

        // Check delete is gone (404) or trashed
        let delete_status = match client.get_asset(&pair.delete.id).await {
            Ok(asset) => {
                if asset.is_trashed {
                    // Delete is in trash - this counts as removed
                    deletes_removed += 1;
                    AssetStatus {
                        asset_id: pair.delete.id.clone(),
                        filename: pair.delete.original_file_name.clone(),
                        status: "trashed".to_string(),
                        error: None,
                    }
                } else {
                    // Delete still exists and not trashed - this is wrong!
                    deletes_still_present += 1;
                    anomalies.push(format!(
                        "Delete {} ({}) still exists (not trashed), should be deleted",
                        pair.delete.id, pair.delete.original_file_name
                    ));
                    AssetStatus {
                        asset_id: pair.delete.id.clone(),
                        filename: pair.delete.original_file_name.clone(),
                        status: "present".to_string(),
                        error: Some("Delete should have been removed".to_string()),
                    }
                }
            }
            Err(immich_lib::ImmichError::Api { status: 404, .. }) => {
                // Delete correctly removed (permanently deleted)
                deletes_removed += 1;
                AssetStatus {
                    asset_id: pair.delete.id.clone(),
                    filename: pair.delete.original_file_name.clone(),
                    status: "deleted".to_string(),
                    error: None,
                }
            }
            Err(e) => {
                // Some other error
                anomalies.push(format!(
                    "Error checking delete {}: {}",
                    pair.delete.id, e
                ));
                AssetStatus {
                    asset_id: pair.delete.id.clone(),
                    filename: pair.delete.original_file_name.clone(),
                    status: "error".to_string(),
                    error: Some(e.to_string()),
                }
            }
        };

        pair_results.push(LetterboxPairVerification {
            timestamp: pair.timestamp.clone(),
            keeper_status,
            delete_status,
        });

        // Progress indicator
        if pairs_verified % 10 == 0 {
            print!(".");
            std::io::stdout().flush()?;
        }
    }
    if !analysis.pairs.is_empty() {
        println!();
        println!();
    }

    // Build report
    let report = LetterboxVerificationReport {
        verified_at: Utc::now(),
        server_url: url.to_string(),
        pairs_verified,
        keepers_present,
        keepers_missing,
        deletes_removed,
        deletes_still_present,
        pairs: pair_results,
        anomalies: anomalies.clone(),
    };

    // Output based on format
    match format.to_lowercase().as_str() {
        "json" => {
            println!("{}", serde_json::to_string_pretty(&report)?);
        }
        _ => {
            println!("Letterbox Verification Report");
            println!("=============================");
            println!();
            println!("Pairs verified:        {}", pairs_verified);
            println!("Keepers present:       {}/{}", keepers_present, pairs_verified);
            println!("Keepers missing:       {}", keepers_missing);
            println!("Deletes removed:       {}", deletes_removed);
            println!("Deletes still present: {}", deletes_still_present);

            if !anomalies.is_empty() {
                println!();
                println!("Anomalies ({}):", anomalies.len());
                for anomaly in &anomalies {
                    println!("  - {}", anomaly);
                }
            }

            println!();
            if keepers_missing == 0 && deletes_still_present == 0 {
                println!("VERIFICATION PASSED");
            } else {
                println!("VERIFICATION FAILED");
            }
        }
    }

    Ok(())
}

/// Execution report for letterbox removal.
#[derive(Debug, Serialize)]
struct LetterboxExecutionReport {
    /// Timestamp when execution was performed
    executed_at: DateTime<Utc>,
    /// The server URL that was targeted
    server_url: String,
    /// Total pairs processed
    total_pairs: usize,
    /// Successfully downloaded files
    downloaded: usize,
    /// Successfully deleted assets
    deleted: usize,
    /// Failed operations
    failed: usize,
    /// Skipped pairs (download failed, so delete skipped)
    skipped: usize,
    /// Individual pair results
    results: Vec<LetterboxPairResult>,
}

/// Result for a single letterbox pair execution.
#[derive(Debug, Serialize)]
struct LetterboxPairResult {
    /// Shared capture timestamp
    timestamp: String,
    /// Keeper asset ID (4:3, kept)
    keeper_id: String,
    /// Delete asset ID (16:9, removed)
    delete_id: String,
    /// Download status: "success", "failed", "skipped"
    download_status: String,
    /// Delete status: "deleted", "trashed", "failed", "skipped"
    delete_status: String,
    /// Error message if any operation failed
    error: Option<String>,
}

async fn run_letterbox_execute(
    url: &str,
    api_key: &str,
    input: &PathBuf,
    backup_dir: &PathBuf,
    force: bool,
    rate_limit: u32,
    yes: bool,
) -> Result<()> {
    // Read and parse letterbox analysis JSON
    let file = File::open(input)
        .with_context(|| format!("Failed to open input file: {}", input.display()))?;
    let reader = BufReader::new(file);
    let analysis: LetterboxAnalysis = serde_json::from_reader(reader)
        .context("Failed to parse letterbox analysis JSON")?;

    if analysis.pairs.is_empty() {
        println!("No letterbox pairs to process.");
        return Ok(());
    }

    // Create backup directory if it doesn't exist
    std::fs::create_dir_all(backup_dir)
        .with_context(|| format!("Failed to create backup directory: {}", backup_dir.display()))?;

    // Print execution summary
    println!();
    println!("Letterbox Execution Plan");
    println!("========================");
    println!("Pairs to process:     {}", analysis.pairs.len());
    if analysis.total_space_recoverable > 0 {
        let size_mb = analysis.total_space_recoverable as f64 / 1_048_576.0;
        println!("Estimated disk space: {:.1} MB", size_mb);
    }
    println!("Backup directory:     {}", backup_dir.display());
    println!("Force delete:         {}", if force { "yes (permanent)" } else { "no (trash)" });
    println!();

    // Confirmation prompt
    if !yes {
        print!(
            "About to download {} files and delete them from Immich. Continue? [y/N] ",
            analysis.pairs.len()
        );
        std::io::stdout().flush()?;

        let mut response = String::new();
        std::io::stdin().read_line(&mut response)?;
        let response = response.trim().to_lowercase();

        if response != "y" && response != "yes" {
            println!("Aborted.");
            return Ok(());
        }
    }

    println!();
    println!("Starting letterbox execution...");
    println!();

    // Create client
    let client = ImmichClient::new(url, api_key).context("Failed to create Immich client")?;

    // Set up rate limiter
    let quota = Quota::per_second(NonZeroU32::new(rate_limit).unwrap_or(NonZeroU32::new(10).unwrap()));
    let rate_limiter = RateLimiter::direct(quota);

    // Track results
    let mut results = Vec::new();
    let mut downloaded_count = 0;
    let mut deleted_count = 0;
    let mut failed_count = 0;
    let mut skipped_count = 0;

    let total = analysis.pairs.len();

    // Create progress bar
    let pb = ProgressBar::new(total as u64);
    pb.set_style(
        ProgressStyle::default_bar()
            .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} pairs ({eta})")
            .expect("valid template")
            .progress_chars("##-"),
    );

    // Process each pair
    for pair in analysis.pairs.iter() {
        let delete_id = &pair.delete.id;
        let delete_filename = &pair.delete.original_file_name;

        pb.set_message(delete_filename.clone());

        // Rate limit
        rate_limiter.until_ready().await;

        // Build backup path with asset ID prefix
        let safe_filename = format!("{}_{}", &delete_id[..8.min(delete_id.len())], delete_filename);
        let backup_path = backup_dir.join(&safe_filename);

        // Step 1: Download the 16:9 file
        let download_result = client.download_asset(delete_id, &backup_path).await;

        match download_result {
            Ok(_) => {
                downloaded_count += 1;

                // Rate limit before delete
                rate_limiter.until_ready().await;

                // Step 2: Delete the asset (only if download succeeded)
                let delete_result = client.delete_assets(std::slice::from_ref(delete_id), force).await;

                match delete_result {
                    Ok(_) => {
                        deleted_count += 1;
                        results.push(LetterboxPairResult {
                            timestamp: pair.timestamp.clone(),
                            keeper_id: pair.keeper.id.clone(),
                            delete_id: delete_id.clone(),
                            download_status: "success".to_string(),
                            delete_status: if force { "deleted" } else { "trashed" }.to_string(),
                            error: None,
                        });
                    }
                    Err(e) => {
                        failed_count += 1;
                        results.push(LetterboxPairResult {
                            timestamp: pair.timestamp.clone(),
                            keeper_id: pair.keeper.id.clone(),
                            delete_id: delete_id.clone(),
                            download_status: "success".to_string(),
                            delete_status: "failed".to_string(),
                            error: Some(e.to_string()),
                        });
                    }
                }
            }
            Err(e) => {
                failed_count += 1;
                skipped_count += 1;
                results.push(LetterboxPairResult {
                    timestamp: pair.timestamp.clone(),
                    keeper_id: pair.keeper.id.clone(),
                    delete_id: delete_id.clone(),
                    download_status: "failed".to_string(),
                    delete_status: "skipped".to_string(),
                    error: Some(e.to_string()),
                });
            }
        }
        pb.inc(1);
    }

    pb.finish_and_clear();

    // Print summary
    println!();
    println!("Letterbox Execution Complete");
    println!("============================");
    println!("Pairs processed:  {}", total);
    println!("Files downloaded: {}", downloaded_count);
    println!("Files deleted:    {}", deleted_count);
    println!("Failed:           {}", failed_count);
    println!("Skipped:          {}", skipped_count);

    // Build execution report
    let report = LetterboxExecutionReport {
        executed_at: Utc::now(),
        server_url: url.to_string(),
        total_pairs: total,
        downloaded: downloaded_count,
        deleted: deleted_count,
        failed: failed_count,
        skipped: skipped_count,
        results,
    };

    // Write execution report to backup directory
    let timestamp = Utc::now().format("%Y%m%d-%H%M%S");
    let report_path = backup_dir.join(format!("letterbox-execution-{}.json", timestamp));
    let report_file = File::create(&report_path)
        .with_context(|| format!("Failed to create report file: {}", report_path.display()))?;
    let writer = BufWriter::new(report_file);
    serde_json::to_writer_pretty(writer, &report)
        .context("Failed to write execution report")?;

    println!();
    println!("Execution report: {}", report_path.display());

    Ok(())
}