use anyhow::Result;
use anyhow::ensure;
use app_test_support::ChatGptAuthFixture;
use app_test_support::write_chatgpt_auth;
use codex_config::CONFIG_TOML_FILE;
use codex_config::MarketplaceConfigUpdate;
use codex_config::record_user_marketplace;
use codex_config::types::AuthCredentialsStoreMode;
use codex_utils_absolute_path::canonicalize_existing_preserving_symlinks;
use flate2::Compression;
use flate2::write::GzEncoder;
use predicates::prelude::PredicateBooleanExt;
use predicates::str::contains;
use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
use std::path::Path;
use std::process::Output;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use tempfile::TempDir;
use tokio::process::Command;
use wiremock::Mock;
use wiremock::MockServer;
use wiremock::ResponseTemplate;
use wiremock::matchers::header;
use wiremock::matchers::method;
use wiremock::matchers::path;
use wiremock::matchers::query_param;

const MARKETPLACE_HEADER: &str = "MARKETPLACE";
const MARKETPLACE_LIST_HEADER: &str = "MARKETPLACE  ROOT";

fn marketplace_list_row(marketplace_name: &str, root: &Path) -> String {
    format!(
        "{marketplace_name:<width$}  {}",
        root.display(),
        width = MARKETPLACE_HEADER.len()
    )
}

fn codex_command(codex_home: &Path) -> Result<assert_cmd::Command> {
    let mut cmd = assert_cmd::Command::new(codex_utils_cargo_bin::cargo_bin("codex")?);
    cmd.env("CODEX_HOME", codex_home);
    cmd.env("HOME", codex_home);
    Ok(cmd)
}

fn codex_command_in(codex_home: &Path, current_dir: &Path) -> Result<assert_cmd::Command> {
    let mut cmd = codex_command(codex_home)?;
    cmd.current_dir(current_dir);
    Ok(cmd)
}

fn configured_local_marketplace(source: &str) -> MarketplaceConfigUpdate<'_> {
    MarketplaceConfigUpdate {
        source_type: "local",
        source,
        ref_name: None,
        sparse_paths: &[],
    }
}

fn write_plugins_enabled_config(codex_home: &Path) -> Result<()> {
    std::fs::write(
        codex_home.join(CONFIG_TOML_FILE),
        r#"[features]
plugins = true
"#,
    )?;
    Ok(())
}

fn write_marketplace_source_with_manifest(source: &Path, marketplace_manifest: &str) -> Result<()> {
    std::fs::create_dir_all(source.join(".agents").join("plugins"))?;
    std::fs::create_dir_all(source.join("plugins").join("sample").join(".codex-plugin"))?;
    std::fs::write(
        source
            .join(".agents")
            .join("plugins")
            .join("marketplace.json"),
        marketplace_manifest,
    )?;
    std::fs::write(
        source
            .join("plugins")
            .join("sample")
            .join(".codex-plugin")
            .join("plugin.json"),
        r#"{"name":"sample","version":"1.2.3","description":"Sample plugin"}"#,
    )?;
    Ok(())
}

fn write_marketplace_source(source: &Path) -> Result<()> {
    write_marketplace_source_with_manifest(
        source,
        r#"{
  "name": "debug",
  "plugins": [
    {
      "name": "sample",
      "source": {
        "source": "local",
        "path": "./plugins/sample"
      }
    }
  ]
}"#,
    )
}

fn write_marketplace_source_with_explicit_empty_products(source: &Path) -> Result<()> {
    write_marketplace_source_with_manifest(
        source,
        r#"{
  "name": "debug",
  "plugins": [
    {
      "name": "sample",
      "source": {
        "source": "local",
        "path": "./plugins/sample"
      },
      "policy": {
        "products": []
      }
    }
  ]
}"#,
    )
}

fn setup_local_marketplace() -> Result<(TempDir, TempDir)> {
    let codex_home = TempDir::new()?;
    let source = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source(source.path())?;
    let source_path = source.path().to_string_lossy().into_owned();
    record_user_marketplace(
        codex_home.path(),
        "debug",
        &configured_local_marketplace(&source_path),
    )?;
    Ok((codex_home, source))
}

fn setup_unconfigured_local_marketplace() -> Result<(TempDir, TempDir)> {
    let codex_home = TempDir::new()?;
    let source = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source(source.path())?;
    Ok((codex_home, source))
}

fn setup_local_marketplace_with_explicit_empty_products() -> Result<(TempDir, TempDir)> {
    let codex_home = TempDir::new()?;
    let source = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source_with_explicit_empty_products(source.path())?;
    let source_path = source.path().to_string_lossy().into_owned();
    record_user_marketplace(
        codex_home.path(),
        "debug",
        &configured_local_marketplace(&source_path),
    )?;
    Ok((codex_home, source))
}

fn setup_configured_marketplace_without_manifest() -> Result<(TempDir, TempDir)> {
    let codex_home = TempDir::new()?;
    let source = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    let source_path = source.path().to_string_lossy().into_owned();
    record_user_marketplace(
        codex_home.path(),
        "debug",
        &configured_local_marketplace(&source_path),
    )?;
    Ok((codex_home, source))
}

fn setup_configured_marketplace_with_malformed_manifest() -> Result<(TempDir, TempDir)> {
    let codex_home = TempDir::new()?;
    let source = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    std::fs::create_dir_all(source.path().join(".agents").join("plugins"))?;
    std::fs::write(
        source
            .path()
            .join(".agents")
            .join("plugins")
            .join("marketplace.json"),
        "{not valid json",
    )?;
    let source_path = source.path().to_string_lossy().into_owned();
    record_user_marketplace(
        codex_home.path(),
        "debug",
        &configured_local_marketplace(&source_path),
    )?;
    Ok((codex_home, source))
}

fn setup_local_marketplace_with_implicit_system_roots() -> Result<(TempDir, TempDir, TempDir)> {
    let (codex_home, source) = setup_local_marketplace()?;

    let bundled_root = codex_home
        .path()
        .join(".tmp")
        .join("bundled-marketplaces")
        .join("openai-bundled");
    std::fs::create_dir_all(&bundled_root)?;
    let bundled_source = bundled_root.display().to_string();
    record_user_marketplace(
        codex_home.path(),
        "openai-bundled",
        &configured_local_marketplace(&bundled_source),
    )?;

    let cache_home = TempDir::new()?;
    let runtime_root = cache_home
        .path()
        .join(".cache")
        .join("codex-runtimes")
        .join("codex-primary-runtime")
        .join("plugins")
        .join("openai-primary-runtime");
    std::fs::create_dir_all(&runtime_root)?;
    let runtime_source = runtime_root.display().to_string();
    record_user_marketplace(
        codex_home.path(),
        "openai-primary-runtime",
        &configured_local_marketplace(&runtime_source),
    )?;

    Ok((codex_home, source, cache_home))
}

fn setup_custom_marketplace_under_implicit_system_root() -> Result<(TempDir, std::path::PathBuf)> {
    let codex_home = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;

    let custom_root = codex_home
        .path()
        .join(".tmp")
        .join("bundled-marketplaces")
        .join("custom-marketplace");
    std::fs::create_dir_all(&custom_root)?;
    let custom_source = custom_root.display().to_string();
    record_user_marketplace(
        codex_home.path(),
        "custom-marketplace",
        &configured_local_marketplace(&custom_source),
    )?;

    Ok((codex_home, custom_root))
}

fn remove_installed_plugin_config(codex_home: &Path, plugin_key: &str) -> Result<()> {
    let config_path = codex_home.join(CONFIG_TOML_FILE);
    let plugin_header = format!("[plugins.\"{plugin_key}\"]");
    let config = std::fs::read_to_string(&config_path)?;
    let mut rewritten = Vec::new();
    let mut skipping = false;

    for line in config.lines() {
        if line == plugin_header {
            skipping = true;
            continue;
        }
        if skipping && line.starts_with('[') {
            skipping = false;
        }
        if !skipping {
            rewritten.push(line);
        }
    }

    std::fs::write(config_path, format!("{}\n", rewritten.join("\n")))?;
    Ok(())
}

fn setup_configured_local_marketplace_with_missing_source() -> Result<TempDir> {
    let codex_home = TempDir::new()?;
    std::fs::write(
        codex_home.path().join(CONFIG_TOML_FILE),
        r#"[features]
plugins = true

[marketplaces.debug]
source_type = "local"
"#,
    )?;
    Ok(codex_home)
}

fn setup_configured_local_marketplace_with_invalid_name() -> Result<TempDir> {
    let codex_home = TempDir::new()?;
    std::fs::write(
        codex_home.path().join(CONFIG_TOML_FILE),
        r#"[features]
plugins = true

[marketplaces."bad/name"]
source_type = "local"
source = "/tmp/debug"
"#,
    )?;
    Ok(codex_home)
}

fn assert_configured_marketplace_snapshot_failure(
    assert: assert_cmd::assert::Assert,
    source: &Path,
    detail: &str,
) {
    assert
        .failure()
        .stderr(contains(
            "failed to load configured marketplace snapshot(s):",
        ))
        .stderr(contains("`debug`"))
        .stderr(contains(source.display().to_string()))
        .stderr(contains(detail));
}

fn assert_marketplace_failure(
    assert: assert_cmd::assert::Assert,
    marketplace_name: &str,
    source: &Path,
    detail: &str,
) {
    assert
        .failure()
        .stderr(contains("failed to load marketplace(s):"))
        .stderr(contains(format!("`{marketplace_name}`")))
        .stderr(contains(source.display().to_string()))
        .stderr(contains(detail));
}

#[tokio::test]
async fn marketplace_list_shows_configured_marketplace_names() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace()?;
    let expected_row = marketplace_list_row("debug", source.path());

    codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "list"])
        .assert()
        .success()
        .stdout(contains(MARKETPLACE_LIST_HEADER))
        .stdout(contains(&expected_row))
        .stdout(contains("\t").not());

    Ok(())
}

#[tokio::test]
async fn marketplace_list_json_prints_configured_marketplaces() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace()?;
    let source_path = source.path().display().to_string();

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "list", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "marketplaces": [
                {
                    "name": "debug",
                    "root": source_path,
                    "marketplaceSource": {
                        "sourceType": "local",
                        "source": source_path,
                    },
                },
            ],
        })
    );

    Ok(())
}

#[tokio::test]
async fn marketplace_list_json_includes_configured_git_marketplace_source() -> Result<()> {
    let codex_home = TempDir::new()?;
    let marketplace_root = codex_home
        .path()
        .join(".tmp")
        .join("marketplaces")
        .join("debug");
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source(&marketplace_root)?;
    let update = MarketplaceConfigUpdate {
        source_type: "git",
        source: "https://example.com/acme/agent-skills.git",
        ref_name: None,
        sparse_paths: &[],
    };
    record_user_marketplace(codex_home.path(), "debug", &update)?;
    let normalized_root = canonicalize_existing_preserving_symlinks(&marketplace_root)?;

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "list", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "marketplaces": [
                {
                    "name": "debug",
                    "root": normalized_root.display().to_string(),
                    "marketplaceSource": {
                        "sourceType": "git",
                        "source": "https://example.com/acme/agent-skills.git",
                    },
                },
            ],
        })
    );

    Ok(())
}

#[tokio::test]
async fn marketplace_list_json_keys_configured_source_by_root() -> Result<()> {
    let codex_home = TempDir::new()?;
    let home = TempDir::new()?;
    let marketplace_root = codex_home
        .path()
        .join(".tmp")
        .join("marketplaces")
        .join("debug");
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source(home.path())?;
    write_marketplace_source(&marketplace_root)?;
    let update = MarketplaceConfigUpdate {
        source_type: "git",
        source: "https://example.com/acme/agent-skills.git",
        ref_name: None,
        sparse_paths: &[],
    };
    record_user_marketplace(codex_home.path(), "debug", &update)?;
    let normalized_root = canonicalize_existing_preserving_symlinks(&marketplace_root)?;

    let assert = codex_command(codex_home.path())?
        .env("HOME", home.path())
        .args(["plugin", "marketplace", "list", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "marketplaces": [
                {
                    "name": "debug",
                    "root": home.path().display().to_string(),
                },
                {
                    "name": "debug",
                    "root": normalized_root.display().to_string(),
                    "marketplaceSource": {
                        "sourceType": "git",
                        "source": "https://example.com/acme/agent-skills.git",
                    },
                },
            ],
        })
    );

    Ok(())
}

#[tokio::test]
async fn marketplace_list_includes_home_marketplace_when_present() -> Result<()> {
    let codex_home = TempDir::new()?;
    let home = TempDir::new()?;
    write_marketplace_source(home.path())?;
    write_plugins_enabled_config(codex_home.path())?;
    let expected_row = marketplace_list_row("debug", home.path());

    codex_command(codex_home.path())?
        .env("HOME", home.path())
        .args(["plugin", "marketplace", "list"])
        .assert()
        .success()
        .stdout(contains(MARKETPLACE_LIST_HEADER))
        .stdout(contains(&expected_row))
        .stdout(contains("\t").not());

    Ok(())
}

#[tokio::test]
async fn marketplace_list_includes_root_when_plugins_are_filtered_out() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace_with_explicit_empty_products()?;
    let expected_row = marketplace_list_row("debug", source.path());

    codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "list"])
        .assert()
        .success()
        .stdout(contains(MARKETPLACE_LIST_HEADER))
        .stdout(contains(&expected_row));

    Ok(())
}

#[tokio::test]
async fn marketplace_list_fails_when_configured_marketplace_snapshot_is_missing() -> Result<()> {
    let (codex_home, source) = setup_configured_marketplace_without_manifest()?;

    assert_marketplace_failure(
        codex_command(codex_home.path())?
            .args(["plugin", "marketplace", "list"])
            .assert(),
        "debug",
        source.path(),
        "marketplace root does not contain a supported manifest",
    );

    Ok(())
}

#[tokio::test]
async fn marketplace_list_fails_when_configured_marketplace_name_is_invalid() -> Result<()> {
    let codex_home = setup_configured_local_marketplace_with_invalid_name()?;

    assert_marketplace_failure(
        codex_command(codex_home.path())?
            .args(["plugin", "marketplace", "list"])
            .assert(),
        "bad/name",
        Path::new("<invalid config>"),
        "marketplace name",
    );

    Ok(())
}

#[tokio::test]
async fn marketplace_list_fails_when_configured_local_marketplace_source_is_missing() -> Result<()>
{
    let codex_home = setup_configured_local_marketplace_with_missing_source()?;

    codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "list"])
        .assert()
        .failure()
        .stderr(contains("failed to load marketplace(s):"))
        .stderr(contains("`debug`"))
        .stderr(contains("<invalid source>"))
        .stderr(contains(
            "configured local marketplace source is missing or empty",
        ));

    Ok(())
}

#[tokio::test]
async fn marketplace_list_fails_when_home_marketplace_is_malformed() -> Result<()> {
    let codex_home = TempDir::new()?;
    let home = TempDir::new()?;
    write_plugins_enabled_config(codex_home.path())?;
    std::fs::create_dir_all(home.path().join(".agents/plugins"))?;
    let home_marketplace_path = home
        .path()
        .join(".agents")
        .join("plugins")
        .join("marketplace.json");
    std::fs::write(&home_marketplace_path, "{not valid json")?;

    codex_command(codex_home.path())?
        .env("HOME", home.path())
        .args(["plugin", "marketplace", "list"])
        .assert()
        .failure()
        .stderr(contains("failed to load marketplace(s):"))
        .stderr(contains(home_marketplace_path.display().to_string()))
        .stderr(contains("key must be a string"));

    Ok(())
}

#[tokio::test]
async fn marketplace_list_fails_when_configured_marketplace_snapshot_is_malformed() -> Result<()> {
    let (codex_home, source) = setup_configured_marketplace_with_malformed_manifest()?;

    assert_marketplace_failure(
        codex_command(codex_home.path())?
            .args(["plugin", "marketplace", "list"])
            .assert(),
        "debug",
        source.path(),
        "key must be a string",
    );

    Ok(())
}

#[tokio::test]
async fn plugin_list_prints_plugins_in_a_table() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace()?;
    let marketplace_manifest = source
        .path()
        .join(".agents")
        .join("plugins")
        .join("marketplace.json");
    let plugin_path = source.path().join("plugins").join("sample");

    codex_command(codex_home.path())?
        .args(["plugin", "list"])
        .assert()
        .success()
        .stdout(contains("Marketplace `debug`"))
        .stdout(contains("PLUGIN"))
        .stdout(contains("STATUS"))
        .stdout(contains("VERSION"))
        .stdout(contains("SOURCE"))
        .stdout(contains(marketplace_manifest.display().to_string()))
        .stdout(contains("sample@debug"))
        .stdout(contains("not installed"))
        .stdout(contains(plugin_path.display().to_string()));

    Ok(())
}

#[tokio::test]
async fn plugin_list_json_prints_available_plugins_when_requested() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace()?;
    let plugin_path = source.path().join("plugins").join("sample");
    let source_path = source.path().to_string_lossy().into_owned();

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "list", "--available", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "installed": [],
            "available": [
                {
                    "pluginId": "sample@debug",
                    "name": "sample",
                    "marketplaceName": "debug",
                    "version": "1.2.3",
                    "installed": false,
                    "enabled": false,
                    "source": {
                        "source": "local",
                        "path": plugin_path.display().to_string(),
                    },
                    "marketplaceSource": {
                        "sourceType": "local",
                        "source": source_path,
                    },
                    "installPolicy": "AVAILABLE",
                    "authPolicy": "ON_INSTALL",
                },
            ],
        })
    );

    Ok(())
}

#[tokio::test]
async fn plugin_list_json_includes_configured_git_marketplace_source() -> Result<()> {
    let codex_home = TempDir::new()?;
    let marketplace_root = codex_home
        .path()
        .join(".tmp")
        .join("marketplaces")
        .join("debug");
    write_plugins_enabled_config(codex_home.path())?;
    write_marketplace_source(&marketplace_root)?;
    let update = MarketplaceConfigUpdate {
        source_type: "git",
        source: "https://example.com/acme/agent-skills.git",
        ref_name: None,
        sparse_paths: &[],
    };
    record_user_marketplace(codex_home.path(), "debug", &update)?;
    let plugin_path = marketplace_root.join("plugins").join("sample");
    let normalized_plugin_path = canonicalize_existing_preserving_symlinks(&plugin_path)?;

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "list", "--available", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "installed": [],
            "available": [
                {
                    "pluginId": "sample@debug",
                    "name": "sample",
                    "marketplaceName": "debug",
                    "version": "1.2.3",
                    "installed": false,
                    "enabled": false,
                    "source": {
                        "source": "local",
                        "path": normalized_plugin_path.display().to_string(),
                    },
                    "marketplaceSource": {
                        "sourceType": "git",
                        "source": "https://example.com/acme/agent-skills.git",
                    },
                    "installPolicy": "AVAILABLE",
                    "authPolicy": "ON_INSTALL",
                },
            ],
        })
    );

    Ok(())
}

#[tokio::test]
async fn plugin_list_json_prints_installed_plugins() -> Result<()> {
    let (codex_home, source) = setup_local_marketplace()?;
    let plugin_path = source.path().join("plugins").join("sample");
    let source_path = source.path().to_string_lossy().into_owned();

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "list", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "installed": [
                {
                    "pluginId": "sample@debug",
                    "name": "sample",
                    "marketplaceName": "debug",
                    "version": "1.2.3",
                    "installed": true,
                    "enabled": true,
                    "source": {
                        "source": "local",
                        "path": plugin_path.display().to_string(),
                    },
                    "marketplaceSource": {
                        "sourceType": "local",
                        "source": source_path,
                    },
                    "installPolicy": "AVAILABLE",
                    "authPolicy": "ON_INSTALL",
                },
            ],
            "available": [],
        })
    );

    Ok(())
}

#[tokio::test]
async fn plugin_list_available_requires_json() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "list", "--available"])
        .assert()
        .failure()
        .stderr(contains(
            "the following required arguments were not provided",
        ))
        .stderr(contains("--json"));

    Ok(())
}

#[tokio::test]
async fn plugin_list_shows_installed_version_when_plugin_is_installed() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    codex_command(codex_home.path())?
        .args(["plugin", "list"])
        .assert()
        .success()
        .stdout(contains("sample@debug"))
        .stdout(contains("1.2.3"))
        .stdout(contains("installed, enabled"));

    Ok(())
}

#[tokio::test]
async fn plugin_list_excludes_unconfigured_repo_local_marketplaces() -> Result<()> {
    let (codex_home, source) = setup_unconfigured_local_marketplace()?;

    codex_command_in(codex_home.path(), source.path())?
        .args(["plugin", "list", "--marketplace", "debug"])
        .assert()
        .success()
        .stdout(contains("No plugins found in marketplace `debug`."))
        .stdout(predicates::str::is_match("sample@debug").unwrap().not());

    Ok(())
}

#[tokio::test]
async fn plugin_list_fails_when_configured_marketplace_snapshot_is_missing() -> Result<()> {
    let (codex_home, source) = setup_configured_marketplace_without_manifest()?;

    assert_configured_marketplace_snapshot_failure(
        codex_command(codex_home.path())?
            .args(["plugin", "list"])
            .assert(),
        source.path(),
        "marketplace root does not contain a supported manifest",
    );

    Ok(())
}

#[tokio::test]
async fn plugin_list_ignores_implicit_system_marketplace_roots_without_manifests() -> Result<()> {
    let (codex_home, source, cache_home) = setup_local_marketplace_with_implicit_system_roots()?;

    codex_command(codex_home.path())?
        .env("HOME", cache_home.path())
        .env("USERPROFILE", cache_home.path())
        .args(["plugin", "list"])
        .assert()
        .success()
        .stdout(contains("Marketplace `debug`"))
        .stdout(contains(
            source
                .path()
                .join(".agents")
                .join("plugins")
                .join("marketplace.json")
                .display()
                .to_string(),
        ))
        .stderr(
            predicates::str::contains("failed to load configured marketplace snapshot(s):").not(),
        );

    Ok(())
}

#[tokio::test]
async fn plugin_list_fails_for_custom_marketplace_under_system_root() -> Result<()> {
    let (codex_home, custom_root) = setup_custom_marketplace_under_implicit_system_root()?;

    codex_command(codex_home.path())?
        .args(["plugin", "list"])
        .assert()
        .failure()
        .stderr(contains(
            "failed to load configured marketplace snapshot(s):",
        ))
        .stderr(contains("`custom-marketplace`"))
        .stderr(contains(custom_root.display().to_string()))
        .stderr(contains(
            "marketplace root does not contain a supported manifest",
        ));

    Ok(())
}

#[tokio::test]
async fn plugin_list_hides_version_for_cached_but_unconfigured_plugin() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    remove_installed_plugin_config(codex_home.path(), "sample@debug")?;

    codex_command(codex_home.path())?
        .args(["plugin", "list"])
        .assert()
        .success()
        .stdout(contains("sample@debug"))
        .stdout(contains("not installed"))
        .stdout(predicates::str::contains("1.2.3").not());

    Ok(())
}

#[tokio::test]
async fn plugin_add_and_remove_updates_installed_plugin_config() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success()
        .stdout(contains("Added plugin `sample` from marketplace `debug`."));

    let config = std::fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE))?;
    assert!(config.contains("[plugins.\"sample@debug\"]"));

    codex_command(codex_home.path())?
        .args(["plugin", "remove", "sample", "--marketplace", "debug"])
        .assert()
        .success()
        .stdout(contains(
            "Removed plugin `sample` from marketplace `debug`.",
        ));

    let config = std::fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE))?;
    assert!(!config.contains("[plugins.\"sample@debug\"]"));

    Ok(())
}

#[tokio::test]
async fn plugin_add_json_prints_install_outcome() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    let assert = codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug", "--json"])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;
    let installed_path = codex_home.path().join("plugins/cache/debug/sample/1.2.3");
    let normalized_installed_path = canonicalize_existing_preserving_symlinks(&installed_path)?;

    assert_eq!(
        actual,
        json!({
            "pluginId": "sample@debug",
            "name": "sample",
            "marketplaceName": "debug",
            "version": "1.2.3",
            "installedPath": normalized_installed_path.display().to_string(),
            "authPolicy": "ON_INSTALL",
        })
    );

    Ok(())
}

#[tokio::test]
async fn plugin_remove_json_prints_remove_outcome() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    let assert = codex_command(codex_home.path())?
        .args([
            "plugin",
            "remove",
            "sample",
            "--marketplace",
            "debug",
            "--json",
        ])
        .assert()
        .success();
    let stdout = assert.get_output().stdout.as_slice();
    let actual: serde_json::Value = serde_json::from_slice(stdout)?;

    assert_eq!(
        actual,
        json!({
            "pluginId": "sample@debug",
            "name": "sample",
            "marketplaceName": "debug",
        })
    );

    Ok(())
}

#[tokio::test]
async fn plugin_add_rejects_unconfigured_repo_local_marketplaces() -> Result<()> {
    let (codex_home, source) = setup_unconfigured_local_marketplace()?;

    codex_command_in(codex_home.path(), source.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .failure()
        .stderr(contains(
            "plugin `sample` was not found in marketplace `debug`",
        ));

    Ok(())
}

#[tokio::test]
async fn plugin_add_fails_when_configured_marketplace_snapshot_is_malformed() -> Result<()> {
    let (codex_home, source) = setup_configured_marketplace_with_malformed_manifest()?;

    assert_configured_marketplace_snapshot_failure(
        codex_command(codex_home.path())?
            .args(["plugin", "add", "sample@debug"])
            .assert(),
        source.path(),
        "key must be a string",
    );

    Ok(())
}

#[tokio::test]
async fn plugin_add_reinstalls_from_configured_marketplace_snapshot() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success()
        .stdout(contains("Added plugin `sample` from marketplace `debug`."));

    assert!(
        codex_home
            .path()
            .join("plugins/cache/debug/sample/1.2.3/.codex-plugin/plugin.json")
            .is_file()
    );

    Ok(())
}

#[tokio::test]
async fn plugin_remove_works_after_marketplace_is_removed() -> Result<()> {
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample", "--marketplace", "debug"])
        .assert()
        .success();

    codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "remove", "debug"])
        .assert()
        .success();

    codex_command(codex_home.path())?
        .args(["plugin", "remove", "sample@debug"])
        .assert()
        .success()
        .stdout(contains(
            "Removed plugin `sample` from marketplace `debug`.",
        ));

    let config = std::fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE))?;
    assert!(!config.contains("[plugins.\"sample@debug\"]"));

    Ok(())
}

#[tokio::test]
async fn plugin_add_rejects_cached_plugins_without_authorizing_marketplace_snapshot() -> Result<()>
{
    let (codex_home, _source) = setup_local_marketplace()?;

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .success();

    codex_command(codex_home.path())?
        .args(["plugin", "marketplace", "remove", "debug"])
        .assert()
        .success();

    assert!(
        codex_home
            .path()
            .join("plugins/cache/debug/sample/1.2.3/.codex-plugin/plugin.json")
            .is_file()
    );

    codex_command(codex_home.path())?
        .args(["plugin", "add", "sample@debug"])
        .assert()
        .failure()
        .stderr(contains(
            "plugin `sample` was not found in marketplace `debug`",
        ));

    Ok(())
}

const REMOTE_ID: &str = "b1234567-89ab-4cde-8f01-234567890abc";
const MARKETPLACE: &str = "openai-curated-remote";
const PLUGIN_KEY: &str = "sample@openai-curated-remote";

fn sample_remote_plugin_bundle() -> Result<Vec<u8>> {
    let mut archive = tar::Builder::new(GzEncoder::new(Vec::new(), Compression::default()));
    for (path, contents) in [
        (
            ".codex-plugin/plugin.json",
            r#"{"name":"sample","version":"1.2.3"}"#,
        ),
        (
            "skills/sample/SKILL.md",
            "---\nname: sample\ndescription: Sample remote skill\n---\nSample instructions.\n",
        ),
    ] {
        let mut header = tar::Header::new_gnu();
        header.set_size(contents.len() as u64);
        header.set_mode(/*mode*/ 0o644);
        header.set_cksum();
        archive.append_data(&mut header, path, contents.as_bytes())?;
    }
    Ok(archive.into_inner()?.finish()?)
}

struct RemoteMarketplaceFixture {
    home: TempDir,
    server: MockServer,
    plugin: Value,
}

impl RemoteMarketplaceFixture {
    async fn new() -> Result<Self> {
        let home = TempDir::new()?;
        let server = MockServer::start().await;
        std::fs::write(
            home.path().join("config.toml"),
            format!(
                "cli_auth_credentials_store = 'file'\nchatgpt_base_url = '{}/backend-api'\n[features]\nplugins = true\nremote_plugin = true\n",
                server.uri()
            ),
        )?;
        write_chatgpt_auth(
            home.path(),
            ChatGptAuthFixture::new("chatgpt-token")
                .account_id("account-123")
                .chatgpt_account_id("account-123"),
            AuthCredentialsStoreMode::File,
        )?;
        let plugin = json!({
            "id": REMOTE_ID, "name": "sample", "scope": "GLOBAL",
            "installation_policy": "AVAILABLE", "authentication_policy": "ON_USE",
            "release": {"version": "1.2.3", "display_name": "Sample", "description": "Remote sample",
                "interface": {}, "bundle_download_url": format!("{}/bundle.tar.gz", server.uri())}
        });
        Mock::given(method("GET"))
            .and(path("/backend-api/ps/plugins/list"))
            .and(query_param("scope", "GLOBAL"))
            .and(header("authorization", "Bearer chatgpt-token"))
            .and(header("chatgpt-account-id", "account-123"))
            .respond_with(ResponseTemplate::new(200).set_body_json(
                json!({"plugins": [plugin.clone()], "pagination": {"next_page_token": null}}),
            ))
            .mount(&server)
            .await;
        Ok(Self {
            home,
            server,
            plugin,
        })
    }

    fn write_local_curated_marketplace(&self) -> Result<Value> {
        let source = canonicalize_existing_preserving_symlinks(self.home.path())?
            .join(".tmp")
            .join("plugins");
        let mut manifest = json!({
            "name": "openai-curated",
            "plugins": [{
                "name": "sample",
                "source": {"source": "local", "path": "./plugins/sample"}
            }]
        });
        write_marketplace_source_with_manifest(&source, &manifest.to_string())?;
        std::fs::write(
            self.home.path().join(".tmp").join("plugins.sha"),
            "local-curated",
        )?;
        manifest["name"] = json!("openai-api-curated");
        std::fs::write(
            source
                .join(".agents")
                .join("plugins")
                .join("api_marketplace.json"),
            manifest.to_string(),
        )?;
        Ok(json!({
            "pluginId": "sample@openai-curated", "name": "sample",
            "marketplaceName": "openai-curated", "version": "1.2.3",
            "installed": false, "enabled": false,
            "source": {"source": "local", "path": source.join("plugins").join("sample")},
            "installPolicy": "AVAILABLE", "authPolicy": "ON_INSTALL"
        }))
    }

    async fn run(&self, args: &[&str]) -> Result<Output> {
        Ok(Command::new(codex_utils_cargo_bin::cargo_bin("codex")?)
            .current_dir(self.home.path())
            .env("CODEX_HOME", self.home.path())
            .env("HOME", self.home.path())
            .env_remove("OPENAI_API_KEY")
            .env_remove("CODEX_API_KEY")
            .env_remove("CODEX_ACCESS_TOKEN")
            .env("CODEX_TEST_ALLOW_HTTP_REMOTE_PLUGIN_BUNDLE_DOWNLOADS", "1")
            .args(args)
            .output()
            .await?)
    }

    async fn success(&self, args: &[&str]) -> Result<String> {
        let output = self.run(args).await?;
        ensure!(
            output.status.success(),
            "{}",
            String::from_utf8_lossy(&output.stderr)
        );
        Ok(String::from_utf8(output.stdout)?)
    }
}

#[tokio::test]
async fn remote_plugin_listing_replaces_local_curated_catalog() -> Result<()> {
    let fixture = RemoteMarketplaceFixture::new().await?;
    let mut local_plugin = fixture.write_local_curated_marketplace()?;
    fixture
        .success(&["plugin", "add", "sample@openai-curated"])
        .await?;
    local_plugin["installed"] = json!(true);
    local_plugin["enabled"] = json!(true);
    local_plugin["version"] = json!("local-curated");
    let mut installed_plugin = fixture.plugin.clone();
    installed_plugin["enabled"] = json!(true);
    Mock::given(path("/backend-api/ps/plugins/installed"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "plugins": [installed_plugin], "pagination": {"next_page_token": null}
        })))
        .mount(&fixture.server)
        .await;

    let listed = fixture
        .success(&["plugin", "list", "--available", "--json"])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [{
            "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
            "version": "1.2.3", "installed": true, "enabled": true,
            "source": {"source": "remote", "id": REMOTE_ID},
            "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
        }], "available": []})
    );
    let table = fixture.success(&["plugin", "list"]).await?;
    insta::assert_snapshot!(table, @r"
    Marketplace `openai-curated-remote`
    Remote catalog

    PLUGIN                        STATUS              VERSION  SOURCE
    sample@openai-curated-remote  installed, enabled  1.2.3    b1234567-89ab-4cde-8f01-234567890abc
    ");

    fixture.server.reset().await;
    let listed = fixture
        .success(&["plugin", "list", "-m", "openai-curated", "--json"])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [local_plugin], "available": []})
    );
    assert!(fixture.server.received_requests().await.unwrap().is_empty());
    Ok(())
}

#[tokio::test]
async fn remote_plugin_listing_preserves_local_curated_only_when_fetch_fails() -> Result<()> {
    for status in [200, 403] {
        let fixture = RemoteMarketplaceFixture::new().await?;
        fixture.server.reset().await;
        let local_plugin = fixture.write_local_curated_marketplace()?;
        let response = ResponseTemplate::new(status).set_body_json(json!({
            "plugins": [], "pagination": {"next_page_token": null}
        }));
        let _catalog = Mock::given(path("/backend-api/ps/plugins/list"))
            .respond_with(response)
            .mount_as_scoped(&fixture.server)
            .await;
        Mock::given(path("/backend-api/ps/plugins/installed"))
            .respond_with(ResponseTemplate::new(200).set_body_json(json!({
                "plugins": [], "pagination": {"next_page_token": null}
            })))
            .mount(&fixture.server)
            .await;

        let listed = fixture
            .success(&["plugin", "list", "--available", "--json"])
            .await?;
        let available = if status == 200 {
            Vec::new()
        } else {
            vec![local_plugin]
        };
        assert_eq!(
            serde_json::from_str::<Value>(&listed)?,
            json!({"installed": [], "available": available}),
            "catalog response status: {status}"
        );
    }
    Ok(())
}

#[tokio::test]
async fn remote_plugin_add_list_and_remove() -> Result<()> {
    let fixture = RemoteMarketplaceFixture::new().await?;
    let installed = Arc::new(AtomicBool::new(false));
    let installed_for_list = Arc::clone(&installed);
    let mut installed_plugin = fixture.plugin.clone();
    installed_plugin["enabled"] = json!(true);
    Mock::given(path("/backend-api/ps/plugins/installed"))
        .respond_with(move |_: &wiremock::Request| {
            let plugins = if installed_for_list.load(Ordering::SeqCst) {
                vec![installed_plugin.clone()]
            } else {
                Vec::new()
            };
            ResponseTemplate::new(200)
                .set_body_json(json!({"plugins": plugins, "pagination": {"next_page_token": null}}))
        })
        .mount(&fixture.server)
        .await;
    Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
        .respond_with(ResponseTemplate::new(200).set_body_json(&fixture.plugin))
        .mount(&fixture.server)
        .await;
    Mock::given(path("/bundle.tar.gz"))
        .respond_with(ResponseTemplate::new(200).set_body_bytes(sample_remote_plugin_bundle()?))
        .expect(1)
        .mount(&fixture.server)
        .await;
    let installed_root = canonicalize_existing_preserving_symlinks(fixture.home.path())?
        .join("plugins")
        .join("cache")
        .join(MARKETPLACE)
        .join("sample")
        .join("1.2.3");
    let manifest = installed_root.join(".codex-plugin/plugin.json");
    let installed_for_add = Arc::clone(&installed);
    Mock::given(method("POST"))
        .and(path(format!("/backend-api/ps/plugins/{REMOTE_ID}/install")))
        .and(query_param("includeAppsNeedingAuth", "true"))
        .and(header("authorization", "Bearer chatgpt-token"))
        .respond_with(move |_: &wiremock::Request| {
            assert!(
                manifest.is_file(),
                "cache must exist before backend install"
            );
            installed_for_add.store(true, Ordering::SeqCst);
            ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": true}))
        })
        .expect(1)
        .mount(&fixture.server)
        .await;
    Mock::given(method("POST"))
        .and(path(format!(
            "/backend-api/ps/plugins/{REMOTE_ID}/uninstall"
        )))
        .and(header("authorization", "Bearer chatgpt-token"))
        .respond_with(move |_: &wiremock::Request| {
            installed.store(false, Ordering::SeqCst);
            ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": false}))
        })
        .expect(1)
        .mount(&fixture.server)
        .await;

    let available = json!({
        "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
        "version": "1.2.3", "installed": false, "enabled": false,
        "source": {"source": "remote", "id": REMOTE_ID}, "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
    });
    let listed = fixture
        .success(&["plugin", "list", "--available", "--json"])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [], "available": [available.clone()]})
    );
    let table = fixture
        .success(&["plugin", "list", "-m", MARKETPLACE])
        .await?;
    insta::assert_snapshot!(table, @r"
    Marketplace `openai-curated-remote`
    Remote catalog

    PLUGIN                        STATUS         VERSION  SOURCE
    sample@openai-curated-remote  not installed  1.2.3    b1234567-89ab-4cde-8f01-234567890abc
    ");
    let added = fixture
        .success(&["plugin", "add", PLUGIN_KEY, "--json"])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&added)?,
        json!({
            "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
            "version": "1.2.3", "installedPath": installed_root, "authPolicy": "ON_USE"
        })
    );
    assert_eq!(
        fixture
            .server
            .received_requests()
            .await
            .unwrap()
            .iter()
            .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
            .count(),
        1,
        "installing a cached name must not refetch the catalog"
    );
    assert!(installed_root.join("skills/sample/SKILL.md").is_file());
    let mut expected = available;
    expected["installed"] = json!(true);
    expected["enabled"] = json!(true);
    let listed = fixture
        .success(&["plugin", "list", "-m", MARKETPLACE, "--json"])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [expected], "available": []})
    );
    let _delisted = Mock::given(path("/backend-api/ps/plugins/list"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
        )
        .mount_as_scoped(&fixture.server)
        .await;
    let removed = fixture
        .success(&[
            "-c",
            "features.remote_plugin=false",
            "plugin",
            "remove",
            "sample",
            "-m",
            MARKETPLACE,
            "--json",
        ])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&removed)?,
        json!({"pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE})
    );
    assert!(!installed_root.exists());
    let listed = fixture.success(&["plugin", "list", "--json"]).await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [], "available": []})
    );
    Ok(())
}

#[tokio::test]
async fn remote_plugin_add_refreshes_cached_catalog_on_name_miss() -> Result<()> {
    for (remote_plugin_config, collection) in [
        ("features.remote_plugin=true", None),
        ("features.remote_plugin=false", Some("vertical")),
    ] {
        let fixture = RemoteMarketplaceFixture::new().await?;
        fixture.server.reset().await;
        let published = Arc::new(AtomicBool::new(false));
        let published_for_list = Arc::clone(&published);
        let plugin = fixture.plugin.clone();
        Mock::given(method("GET"))
            .and(path("/backend-api/ps/plugins/list"))
            .and(query_param("scope", "GLOBAL"))
            .respond_with(move |_: &wiremock::Request| {
                let plugins = if published_for_list.load(Ordering::SeqCst) {
                    vec![plugin.clone()]
                } else {
                    Vec::new()
                };
                ResponseTemplate::new(200).set_body_json(json!({
                    "plugins": plugins, "pagination": {"next_page_token": null}
                }))
            })
            .expect(2)
            .mount(&fixture.server)
            .await;
        Mock::given(path("/backend-api/ps/plugins/installed"))
            .respond_with(ResponseTemplate::new(200).set_body_json(json!({
                "plugins": [], "pagination": {"next_page_token": null}
            })))
            .mount(&fixture.server)
            .await;
        Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
            .respond_with(ResponseTemplate::new(200).set_body_json(&fixture.plugin))
            .expect(1)
            .mount(&fixture.server)
            .await;
        Mock::given(path("/bundle.tar.gz"))
            .respond_with(ResponseTemplate::new(200).set_body_bytes(sample_remote_plugin_bundle()?))
            .expect(1)
            .mount(&fixture.server)
            .await;
        Mock::given(method("POST"))
            .and(path(format!("/backend-api/ps/plugins/{REMOTE_ID}/install")))
            .respond_with(
                ResponseTemplate::new(200).set_body_json(json!({"id": REMOTE_ID, "enabled": true})),
            )
            .expect(1)
            .mount(&fixture.server)
            .await;

        for is_published in [false, true] {
            published.store(is_published, Ordering::SeqCst);
            let listed = fixture
                .success(&[
                    "-c",
                    remote_plugin_config,
                    "plugin",
                    "list",
                    "-m",
                    MARKETPLACE,
                    "--available",
                    "--json",
                ])
                .await?;
            assert_eq!(
                serde_json::from_str::<Value>(&listed)?,
                json!({"installed": [], "available": []}),
                "normal listing must keep using the fresh catalog cache"
            );
        }
        let added = fixture
            .success(&[
                "-c",
                remote_plugin_config,
                "plugin",
                "add",
                PLUGIN_KEY,
                "--json",
            ])
            .await?;
        let installed_root = canonicalize_existing_preserving_symlinks(fixture.home.path())?
            .join("plugins")
            .join("cache")
            .join(MARKETPLACE)
            .join("sample")
            .join("1.2.3");
        assert_eq!(
            serde_json::from_str::<Value>(&added)?,
            json!({
                "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
                "version": "1.2.3", "installedPath": installed_root, "authPolicy": "ON_USE"
            })
        );
        assert!(
            installed_root
                .join("skills")
                .join("sample")
                .join("SKILL.md")
                .is_file()
        );
        let requests = fixture.server.received_requests().await.unwrap();
        let catalog_collections = requests
            .iter()
            .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
            .map(|request| {
                request
                    .url
                    .query_pairs()
                    .find_map(|(key, value)| (key == "collection").then(|| value.into_owned()))
            })
            .collect::<Vec<_>>();
        assert_eq!(catalog_collections, vec![collection.map(str::to_owned); 2]);
    }
    Ok(())
}

#[tokio::test]
async fn remote_plugin_add_limits_catalog_refresh_without_mutation() -> Result<()> {
    enum CatalogCache {
        Missing,
        Fresh,
        Expired,
    }

    for (remote_plugin_config, collection) in [
        ("features.remote_plugin=true", None),
        ("features.remote_plugin=false", Some("vertical")),
    ] {
        for (cache, plugin_count, status, catalog_fetches, error) in [
            (
                CatalogCache::Missing,
                0,
                200,
                1,
                "was not found in remote marketplace",
            ),
            (
                CatalogCache::Fresh,
                0,
                200,
                2,
                "was not found in remote marketplace",
            ),
            (
                CatalogCache::Expired,
                0,
                200,
                2,
                "was not found in remote marketplace",
            ),
            (
                CatalogCache::Missing,
                2,
                200,
                1,
                "matched multiple remote plugins",
            ),
            (
                CatalogCache::Missing,
                0,
                403,
                1,
                "failed to list remote marketplace plugins",
            ),
        ] {
            let fixture = RemoteMarketplaceFixture::new().await?;
            fixture.server.reset().await;
            let mut duplicate = fixture.plugin.clone();
            duplicate["id"] = json!("c1234567-89ab-4cde-8f01-234567890abc");
            let plugins = [fixture.plugin.clone(), duplicate]
                .into_iter()
                .take(plugin_count)
                .collect::<Vec<_>>();
            Mock::given(path("/backend-api/ps/plugins/list"))
                .and(query_param("scope", "GLOBAL"))
                .respond_with(ResponseTemplate::new(status).set_body_json(json!({
                    "plugins": plugins, "pagination": {"next_page_token": null}
                })))
                .expect(catalog_fetches)
                .mount(&fixture.server)
                .await;
            Mock::given(path("/backend-api/ps/plugins/installed"))
                .respond_with(ResponseTemplate::new(200).set_body_json(json!({
                    "plugins": [], "pagination": {"next_page_token": null}
                })))
                .mount(&fixture.server)
                .await;
            if !matches!(cache, CatalogCache::Missing) {
                let listed = fixture
                    .success(&[
                        "-c",
                        remote_plugin_config,
                        "plugin",
                        "list",
                        "-m",
                        MARKETPLACE,
                        "--available",
                        "--json",
                    ])
                    .await?;
                assert_eq!(
                    serde_json::from_str::<Value>(&listed)?,
                    json!({"installed": [], "available": []})
                );
            }
            if matches!(cache, CatalogCache::Expired) {
                let cache_paths = std::fs::read_dir(
                    fixture
                        .home
                        .path()
                        .join("cache")
                        .join("remote_plugin_catalog"),
                )?
                .map(|entry| entry.map(|entry| entry.path()))
                .collect::<std::io::Result<Vec<_>>>()?;
                assert_eq!(cache_paths.len(), 1);
                let cache_path = &cache_paths[0];
                let mut cached_catalog: Value =
                    serde_json::from_slice(&std::fs::read(cache_path)?)?;
                cached_catalog["fetched_at"] = json!("2000-01-01T00:00:00Z");
                std::fs::write(cache_path, serde_json::to_vec(&cached_catalog)?)?;
            }
            let output = fixture
                .run(&["-c", remote_plugin_config, "plugin", "add", PLUGIN_KEY])
                .await?;
            assert!(!output.status.success());
            let stderr = String::from_utf8(output.stderr)?;
            assert!(stderr.contains(error), "{stderr}");
            let requests = fixture.server.received_requests().await.unwrap();
            let catalog_collections = requests
                .iter()
                .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
                .map(|request| {
                    request
                        .url
                        .query_pairs()
                        .find_map(|(key, value)| (key == "collection").then(|| value.into_owned()))
                })
                .collect::<Vec<_>>();
            assert_eq!(
                catalog_collections,
                vec![collection.map(str::to_owned); catalog_fetches as usize]
            );
            assert!(requests.iter().all(|request| {
                request.method == "GET"
                    && matches!(
                        request.url.path(),
                        "/backend-api/ps/plugins/list" | "/backend-api/ps/plugins/installed"
                    )
            }));
            assert!(
                !fixture
                    .home
                    .path()
                    .join("plugins")
                    .join("cache")
                    .join(MARKETPLACE)
                    .exists()
            );
        }
    }
    Ok(())
}

#[tokio::test]
async fn remote_plugin_install_checks_policy_and_bundle_before_mutation() -> Result<()> {
    let fixture = RemoteMarketplaceFixture::new().await?;
    Mock::given(path("/backend-api/ps/plugins/installed"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
        )
        .mount(&fixture.server)
        .await;
    for (field, value, error) in [
        ("status", "DISABLED_BY_ADMIN", "disabled by admin"),
        (
            "installation_policy",
            "NOT_AVAILABLE",
            "not available for install",
        ),
        ("status", "ENABLED", "failed to read plugin bundle tar"),
    ] {
        let mut plugin = fixture.plugin.clone();
        plugin[field] = json!(value);
        let _detail = Mock::given(path(format!("/backend-api/ps/plugins/{REMOTE_ID}")))
            .respond_with(ResponseTemplate::new(200).set_body_json(plugin))
            .mount_as_scoped(&fixture.server)
            .await;
        let _bundle = Mock::given(path("/bundle.tar.gz"))
            .respond_with(ResponseTemplate::new(200).set_body_bytes(b"bad gzip"))
            .mount_as_scoped(&fixture.server)
            .await;
        let output = fixture
            .run(&["plugin", "add", "sample", "-m", MARKETPLACE])
            .await?;
        assert!(!output.status.success());
        let stderr = String::from_utf8(output.stderr)?;
        assert!(stderr.contains(error), "{stderr}");
    }
    let requests = fixture.server.received_requests().await.unwrap();
    assert!(requests.iter().all(|request| request.method != "POST"));
    assert_eq!(
        requests
            .iter()
            .filter(|request| request.url.path() == "/backend-api/ps/plugins/list")
            .count(),
        1,
        "installation policy and bundle failures must not refetch the catalog"
    );
    Ok(())
}

#[tokio::test]
async fn remote_plugin_listing_uses_collection_when_remote_catalog_is_disabled() -> Result<()> {
    let fixture = RemoteMarketplaceFixture::new().await?;
    let mut local_plugin = fixture.write_local_curated_marketplace()?;
    Mock::given(path("/backend-api/ps/plugins/installed"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(json!({"plugins": [], "pagination": {"next_page_token": null}})),
        )
        .mount(&fixture.server)
        .await;
    let listed = fixture
        .success(&[
            "-c",
            "features.remote_plugin=false",
            "plugin",
            "list",
            "--available",
            "--json",
        ])
        .await?;
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [], "available": [local_plugin.clone(), {
            "pluginId": PLUGIN_KEY, "name": "sample", "marketplaceName": MARKETPLACE,
            "version": "1.2.3", "installed": false, "enabled": false,
            "source": {"source": "remote", "id": REMOTE_ID},
            "installPolicy": "AVAILABLE", "authPolicy": "ON_USE"
        }]})
    );
    let requests = fixture.server.received_requests().await.unwrap();
    let listing = requests
        .iter()
        .find(|request| request.url.path().ends_with("/list"))
        .unwrap();
    assert!(
        listing
            .url
            .query_pairs()
            .any(|(key, value)| key == "collection" && value == "vertical")
    );
    fixture.server.reset().await;
    fixture
        .success(&["-c", "features.plugins=false", "plugin", "list"])
        .await?;
    fixture
        .success(&["plugin", "list", "-m", "local-only"])
        .await?;
    assert!(fixture.server.received_requests().await.unwrap().is_empty());
    std::fs::remove_file(fixture.home.path().join("auth.json"))?;
    let output = fixture.run(&["plugin", "list", "-m", MARKETPLACE]).await?;
    assert!(!output.status.success());
    assert!(String::from_utf8(output.stderr)?.contains("chatgpt authentication required"));
    let listed = fixture
        .success(&["plugin", "list", "--available", "--json"])
        .await?;
    local_plugin["pluginId"] = json!("sample@openai-api-curated");
    local_plugin["marketplaceName"] = json!("openai-api-curated");
    assert_eq!(
        serde_json::from_str::<Value>(&listed)?,
        json!({"installed": [], "available": [local_plugin]})
    );
    Ok(())
}