use std::path::Path;
use std::process::Command;
use crate::ProgressCallback;
use std::fs;
use pkh::package_info::parse_control_file;

/// Execute the `put` subcommand to upload package to PPA or archive
///
/// # Arguments
/// - series: Target distribution series (e.g. "focal")
/// - dist: Target distribution (e.g. "ubuntu")
/// - version: Package version override
/// - ppa: Target PPA in "user/ppa-name" format
/// - archive: Set to true for official archive uploads
/// - cwd: Current working directory containing source package
/// - progress: Progress callback for UI updates
pub async fn put(
    series: Option<&str>,
    dist: Option<&str>,
    version: Option<&str>,
    ppa: Option<&str>,
    archive: bool,
    cwd: Option<&Path>,
    progress: ProgressCallback<'_>,
) -> Result<(), Box<dyn std::error::Error>> {
    let current_dir = cwd.unwrap_or_else(|| Path::new("."));
    let control_path = current_dir.join("debian/control");
    
    let control_content = fs::read_to_string(&control_path).map_err(|e| {
        format!("Failed to read debian/control: {}. Are you in a source package directory?", e)
    })?;
    
    let package_info = parse_control_file(&control_content)?;
    let package = package_info.source.ok_or("Could not determine package name from debian/control")?;

    if let Some(cb) = progress {
        cb(&package, "Uploading package...", 0, 1);
    }

    // Find .dsc file in current directory
    let dsc_files: Vec<_> = current_dir.read_dir()?
        .filter_map(|entry| {
            let entry = entry.ok()?;
            let path = entry.path();
            if path.extension()? == "dsc" {
                Some(path)
            } else {
                None
            }
        })
        .collect();

    let dsc_file = dsc_files.first().ok_or("No .dsc file found in current directory")?;

    if dsc_files.len() > 1 {
        return Err("Multiple .dsc files found - please make sure only one exists".into());
    }

    if archive {
        println!("Uploading {} to official archive", dsc_file.display());
        // Execute dput with official archive config
        Command::new("dput")
            .arg("ubuntu")
            .arg(dsc_file)
            .status()?;
    } else if let Some(ppa) = ppa {
        println!("Uploading {} to PPA: {}", dsc_file.display(), ppa);
        // Execute dput with PPA target
        Command::new("dput")
            .arg(format!("ppa:{}", ppa))
            .arg(dsc_file)
            .status()?;
    } else {
        return Err("Must specify either --ppa for PPA upload or --archive for official archive".into());
    }

    if let Some(cb) = progress {
        cb(&package, "Upload complete", 1, 1);
    }

    Ok(())
}