use std::process::Command;
use tempfile::TempDir;

fn arc_cmd() -> Command {
    let mut cmd = Command::new(env!("CARGO_BIN_EXE_arc"));
    cmd.env("NO_COLOR", "1");
    cmd
}

#[test]
fn init_creates_arc_directory() {
    let dir = TempDir::new().unwrap();
    let output = arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");
    assert!(output.status.success());
    assert!(dir.path().join(".arc").is_dir());
}

#[test]
fn init_creates_subdirectories() {
    let dir = TempDir::new().unwrap();
    arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");

    let arc = dir.path().join(".arc");
    assert!(arc.join("commits").is_dir());
    assert!(arc.join("bookmarks").is_dir());
    assert!(arc.join("tags").is_dir());
    assert!(arc.join("stashes").is_dir());
}

#[test]
fn init_creates_config_yml() {
    let dir = TempDir::new().unwrap();
    arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");

    let config_path = dir.path().join(".arc").join("config.yml");
    assert!(config_path.exists());

    let contents = std::fs::read_to_string(&config_path).unwrap();
    assert!(contents.contains("bookmark"));
    assert!(contents.contains("main"));
    assert!(contents.contains("remote"));
    assert!(contents.contains("origin"));
}

#[test]
fn init_creates_head() {
    let dir = TempDir::new().unwrap();
    arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");

    let head_path = dir.path().join(".arc").join("HEAD");
    assert!(head_path.exists());

    let contents = std::fs::read_to_string(&head_path).unwrap();
    assert!(contents.contains("unborn"));
    assert!(contents.contains("main"));
}

#[test]
fn init_creates_main_bookmark() {
    let dir = TempDir::new().unwrap();
    arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");

    let bookmark_path = dir.path().join(".arc").join("bookmarks").join("main");
    assert!(bookmark_path.exists());

    let contents = std::fs::read_to_string(&bookmark_path).unwrap();
    assert!(contents.contains("commit"));
}

#[test]
fn init_with_path_creates_repo() {
    let dir = TempDir::new().unwrap();
    let sub = dir.path().join("myrepo");

    let output = arc_cmd()
        .args(["init", sub.to_str().unwrap()])
        .output()
        .expect("failed to run arc");
    assert!(output.status.success());
    assert!(sub.join(".arc").is_dir());
}

#[test]
fn init_fails_if_already_exists() {
    let dir = TempDir::new().unwrap();

    let first = arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");
    assert!(first.status.success());

    let second = arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");
    assert!(!second.status.success());

    let stderr = String::from_utf8_lossy(&second.stderr);
    assert!(stderr.contains("already exists"));
}

#[test]
fn init_prints_path() {
    let dir = TempDir::new().unwrap();
    let output = arc_cmd()
        .arg("init")
        .current_dir(dir.path())
        .output()
        .expect("failed to run arc");

    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("initialized empty arc repository"));
    assert!(stdout.contains(".arc"));
}