codex-mobile-bridge 0.3.7

use super::*;

pub(super) fn run_activate(args: ActivateArgs) -> Result<()> {
    let paths = release::managed_paths()?;
    let release_root = release::resolve_current_release_root()?;
    let current_metadata = release::current_release_metadata(&release_root)?;
    let existing_env = environment::read_env_file(&paths)?;
    let env_values = environment::merge_env_values(&paths, &existing_env, &args.env)?;
    let existing_record = environment::read_install_record(&paths)?;
    release::activate_release(
        &paths,
        &current_metadata,
        &env_values,
        existing_record.as_ref(),
        args.operation.as_str(),
    )?;
    println!(
        "{}",
        json!({
            "operation": args.operation.as_str(),
            "version": current_metadata.version,
            "releasePath": current_metadata.release_root,
        })
    );
    Ok(())
}

pub(super) fn run_self_update(args: SelfUpdateArgs) -> Result<()> {
    let paths = release::managed_paths()?;
    let existing_record =
        environment::read_install_record(&paths)?.context("缺少 install record，无法执行自更新")?;
    let existing_env = environment::read_env_file(&paths)?;
    let env_values = environment::merge_env_values(&paths, &existing_env, &args.env)?;
    let release_root = release::install_release(
        &paths,
        &args.target_version,
        &args.cargo_binary,
        &args.registry,
    )?;
    let metadata = release::load_release_metadata(&release_root)?;
    release::activate_release(
        &paths,
        &metadata,
        &env_values,
        Some(&existing_record),
        "update",
    )?;
    println!(
        "{}",
        json!({
            "operation": "self-update",
            "version": metadata.version,
            "releasePath": metadata.release_root,
        })
    );
    Ok(())
}

pub(super) fn run_rollback(args: RollbackArgs) -> Result<()> {
    let paths = release::managed_paths()?;
    let existing_record =
        environment::read_install_record(&paths)?.context("缺少 install record，无法回滚")?;
    let previous_version = existing_record
        .previous_version
        .as_deref()
        .filter(|value| !value.trim().is_empty())
        .context("当前没有可回滚的上一版")?;
    let existing_env = environment::read_env_file(&paths)?;
    let env_values = environment::merge_env_values(&paths, &existing_env, &args.env)?;

    let target_release_root = existing_record
        .previous_release_path
        .as_deref()
        .map(PathBuf::from)
        .filter(|path| environment::release_binary_path(path).is_some())
        .unwrap_or_else(|| paths.release_root_for_version(previous_version));
    let target_release_root = if environment::release_binary_path(&target_release_root).is_some() {
        target_release_root
    } else {
        release::install_release(&paths, previous_version, &args.cargo_binary, &args.registry)?
    };
    let metadata =
        release::release_metadata_from_previous_record(&existing_record, &target_release_root)
            .unwrap_or(release::load_release_metadata(&target_release_root)?);

    release::rollback_release(&paths, &metadata, &env_values, &existing_record)?;
    println!(
        "{}",
        json!({
            "operation": "rollback",
            "version": metadata.version,
            "releasePath": metadata.release_root,
        })
    );
    Ok(())
}

pub(super) fn run_repair(args: RepairArgs) -> Result<()> {
    let paths = release::managed_paths()?;
    let existing_record = environment::read_install_record(&paths)?;
    let existing_env = environment::read_env_file(&paths)?;
    let env_values = environment::merge_env_values(&paths, &existing_env, &args.env)?;

    let metadata = resolve_repair_metadata(&paths, existing_record.as_ref(), &args)?;
    release::activate_release(
        &paths,
        &metadata,
        &env_values,
        existing_record.as_ref(),
        "repair",
    )?;
    println!(
        "{}",
        json!({
            "operation": "repair",
            "version": metadata.version,
            "releasePath": metadata.release_root,
        })
    );
    Ok(())
}

pub(super) fn print_metadata() -> Result<()> {
    let release_root = release::resolve_current_release_root()?;
    let metadata = release::current_release_metadata(&release_root)?;
    println!("{}", serde_json::to_string(&metadata)?);
    Ok(())
}

pub(super) fn resolve_repair_metadata(
    paths: &ManagedPaths,
    existing_record: Option<&InstallRecord>,
    args: &RepairArgs,
) -> Result<ReleaseMetadata> {
    if let Some(record) = existing_record {
        let current_release_root = record
            .current_release_path
            .as_deref()
            .map(PathBuf::from)
            .unwrap_or_else(|| {
                record
                    .current_version
                    .as_deref()
                    .map(|value| paths.release_root_for_version(value))
                    .unwrap_or_else(|| paths.current_link.clone())
            });
        if environment::release_binary_path(&current_release_root).is_some() {
            if let Some(metadata) =
                release::release_metadata_from_current_record(record, &current_release_root)
            {
                return Ok(metadata);
            }
            return release::load_release_metadata(&current_release_root);
        }
        if let Some(current_version) = record.current_version.as_deref() {
            let release_root = release::install_release(
                paths,
                current_version,
                &args.cargo_binary,
                &args.registry,
            )?;
            return release::load_release_metadata(&release_root);
        }
    }

    let release_root = release::resolve_current_release_root()?;
    release::current_release_metadata(&release_root)
}