mod common;

use std::process::Command;

#[test]
fn test_missing_config_file() {
    let output = Command::new(env!("CARGO_BIN_EXE_pollux"))
        .arg("--config")
        .arg("nonexistent.toml")
        .env("RUST_LOG", "error")
        .output()
        .unwrap();

    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).unwrap();
    let stdout = String::from_utf8(output.stdout).unwrap();
    assert!(stderr.contains("Config file 'nonexistent.toml' not found"));
    assert!(stdout.contains("Create the config file with"));
}

#[test]
fn test_nonexistent_root_directory() {
    let temp_dir = common::setup_test_environment();
    let config_path = temp_dir.path().join("config.toml");
    let config_content = format!(
        r#"
bind_host = "127.0.0.1"

["example.com"]
root = "/definitely/does/not/exist"
cert = "{}"
key = "{}"
    "#,
        temp_dir.path().join("cert.pem").display(),
        temp_dir.path().join("key.pem").display()
    );
    std::fs::write(&config_path, config_content).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_pollux"))
        .arg("--config")
        .arg(&config_path)
        .arg("--quiet")
        .env("RUST_LOG", "error")
        .output()
        .unwrap();

    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains("Failed to parse config file"));
    assert!(stderr.contains(
        "Error for host 'example.com': Root directory '/definitely/does/not/exist' does not exist"
    ));
}

#[test]
fn test_missing_certificate_file() {
    let temp_dir = common::setup_test_environment();
    let config_path = temp_dir.path().join("config.toml");
    let config_content = format!(
        r#"
bind_host = "127.0.0.1"

["example.com"]
root = "{}"
cert = "/nonexistent/cert.pem"
key = "{}"
    "#,
        temp_dir.path().join("content").display(),
        temp_dir.path().join("key.pem").display()
    );
    std::fs::write(&config_path, config_content).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_pollux"))
        .arg("--config")
        .arg(&config_path)
        .arg("--quiet")
        .env("RUST_LOG", "error")
        .output()
        .unwrap();

    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains(
        "Error for host 'example.com': Certificate file '/nonexistent/cert.pem' does not exist"
    ));
    assert!(stderr.contains("Generate or obtain TLS certificates for your domain"));
}

#[test]
fn test_multiple_hosts_missing_certificate() {
    let temp_dir = common::setup_test_environment();
    let config_path = temp_dir.path().join("config.toml");

    // Create host directories
    std::fs::create_dir(temp_dir.path().join("host1")).unwrap();
    std::fs::create_dir(temp_dir.path().join("host2")).unwrap();

    // Generate certificate for only host1
    let cert1_path = temp_dir.path().join("host1_cert.pem");
    let key1_path = temp_dir.path().join("host1_key.pem");

    let cert_result = std::process::Command::new("openssl")
        .args(&[
            "req",
            "-x509",
            "-newkey",
            "rsa:2048",
            "-keyout",
            &key1_path.to_string_lossy(),
            "-out",
            &cert1_path.to_string_lossy(),
            "-days",
            "1",
            "-nodes",
            "-subj",
            "/CN=host1.com",
        ])
        .output();

    if cert_result.is_err() {
        panic!("Failed to generate test certificate");
    }

    let config_content = format!(
        r#"
bind_host = "127.0.0.1"

["host1.com"]
root = "{}"
cert = "{}"
key = "{}"

["host2.com"]
root = "{}"
cert = "/nonexistent/cert.pem"
key = "/nonexistent/key.pem"
"#,
        temp_dir.path().join("host1").display(),
        cert1_path.display(),
        key1_path.display(),
        temp_dir.path().join("host2").display()
    );

    std::fs::write(&config_path, config_content).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_pollux"))
        .arg("--config")
        .arg(&config_path)
        .arg("--quiet")
        .env("RUST_LOG", "error")
        .output()
        .unwrap();

    assert!(!output.status.success());
    let stderr = String::from_utf8(output.stderr).unwrap();
    assert!(stderr.contains(
        "Error for host 'host2.com': Certificate file '/nonexistent/cert.pem' does not exist"
    ));
}