/// Codex headless command for secure-exec VM.
///
/// The prompt mode remains a placeholder command. The ACP session-turn path is
/// disabled until it can delegate to the real Codex agent package instead of a
/// bespoke provider loop.
use std::collections::HashMap;
use std::io::{self, Read};

const VERSION: &str = env!("CARGO_PKG_VERSION");
const SESSION_TURN_DISABLED: &str =
    "codex-exec --session-turn is disabled until the real Codex agent package is wired";
const MAX_PROMPT_BYTES: usize = 64 * 1024;

use codex_network_proxy::NetworkProxy;
use codex_otel::SessionTelemetry;

fn main() {
    let args: Vec<String> = std::env::args().collect();

    if args.iter().any(|a| a == "--help" || a == "-h") {
        print_help();
        return;
    }

    if args.iter().any(|a| a == "--version" || a == "-V") {
        println!("codex-exec {}", VERSION);
        return;
    }

    if args.get(1).map(|s| s.as_str()) == Some("--http-test") {
        return http_test(&args[2..]);
    }

    if args.get(1).map(|s| s.as_str()) == Some("--stub-test") {
        return stub_test();
    }

    if args.get(1).map(|s| s.as_str()) == Some("--session-turn") {
        emit_session_turn_disabled();
        std::process::exit(1);
    }

    let prompt = if args.len() > 1 {
        let prompt = args[1..].join(" ");
        if prompt.len() > MAX_PROMPT_BYTES {
            eprintln!("codex-exec: prompt exceeds {} byte limit", MAX_PROMPT_BYTES);
            std::process::exit(1);
        }
        prompt
    } else {
        let mut input = Vec::new();
        let mut stdin = io::stdin().take((MAX_PROMPT_BYTES + 1) as u64);
        match stdin.read_to_end(&mut input) {
            Ok(_) if input.len() > MAX_PROMPT_BYTES => {
                eprintln!(
                    "codex-exec: stdin prompt exceeds {} byte limit",
                    MAX_PROMPT_BYTES
                );
                std::process::exit(1);
            }
            Ok(_) => match String::from_utf8(input) {
                Ok(input) => input.trim().to_string(),
                Err(error) => {
                    eprintln!("codex-exec: stdin prompt is not valid UTF-8: {}", error);
                    std::process::exit(1);
                }
            },
            Err(error) => {
                eprintln!("codex-exec: failed to read stdin: {}", error);
                std::process::exit(1);
            }
        }
    };

    if prompt.is_empty() {
        eprintln!("codex-exec: no prompt provided");
        eprintln!("usage: codex-exec <prompt>  or  echo '<prompt>' | codex-exec");
        std::process::exit(1);
    }

    eprintln!("codex-exec: headless prompt mode is not wired to the provider yet");
    eprintln!("prompt received ({} bytes)", prompt.len());
    std::process::exit(0);
}

fn emit_session_turn_disabled() {
    println!(
        "{{\"type\":\"error\",\"message\":\"{}\"}}",
        SESSION_TURN_DISABLED
    );
}

fn print_help() {
    println!("codex-exec {} - headless Codex command", VERSION);
    println!();
    println!("USAGE:");
    println!("    codex-exec [OPTIONS] [PROMPT]");
    println!("    echo '<prompt>' | codex-exec");
    println!();
    println!("OPTIONS:");
    println!("    -h, --help          Print this help message");
    println!("    -V, --version       Print version information");
    println!("    --http-test URL     Test HTTP client via host_net");
    println!("    --stub-test         Validate WASI stub crates");
    println!("    --session-turn      Fail fast until the real Codex agent package is wired");
}

fn stub_test() {
    let proxy = NetworkProxy;
    let mut env = HashMap::new();
    proxy.apply_to_env(&mut env);
    println!("network-proxy: NetworkProxy is zero-size, apply_to_env is no-op");

    let telemetry = SessionTelemetry::new();
    telemetry.counter("test.counter", 1, &[]);
    telemetry.histogram("test.histogram", 42, &[]);
    println!("otel: SessionTelemetry metrics are no-ops");

    let global = codex_otel::metrics::global();
    assert!(global.is_none(), "global metrics should be None on WASI");
    println!("otel: global() returns None (no exporter on WASI)");

    println!("stub-test: all stubs validated successfully");
}

fn http_test(args: &[String]) {
    if args.is_empty() {
        eprintln!("usage: codex-exec --http-test <url>");
        std::process::exit(1);
    }

    let url = &args[0];
    match wasi_http::get(url) {
        Ok(resp) => {
            println!("status: {}", resp.status);
            match resp.text() {
                Ok(body) => println!("body: {}", body),
                Err(error) => eprintln!("body decode error: {}", error),
            }
        }
        Err(error) => {
            eprintln!("http error: {}", error);
            std::process::exit(1);
        }
    }
}