//! Remotes kept on a store, through the command line: `oxy remote add`
//! with its store settings, `oxy remote check`, and push, clone and pull
//! through a `dir://` store (docs/stores.md).

use std::path::Path;
use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (i32, String, String) {
    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))
        .arg("--plain")
        .args(args)
        .current_dir(dir)
        .env("OXY_HOME", home)
        .env("NO_COLOR", "1")
        .output()
        .unwrap();
    (
        out.status.code().unwrap_or(-1),
        String::from_utf8_lossy(&out.stdout).to_string(),
        String::from_utf8_lossy(&out.stderr).to_string(),
    )
}

fn ok(dir: &Path, home: &Path, args: &[&str]) -> String {
    let (code, out, err) = oxy(dir, home, args);
    assert_eq!(code, 0, "oxy {args:?}: {out}{err}");
    out
}

#[test]
fn store_remotes_through_the_cli() {
    let tmp = tempfile::tempdir().unwrap();
    let home = tmp.path().join("home");
    std::fs::create_dir_all(&home).unwrap();
    let a = tmp.path().join("a");
    ok(tmp.path(), &home, &["init", a.to_str().unwrap()]);
    std::fs::write(a.join("f.txt"), "hello\n").unwrap();
    ok(&a, &home, &["commit", "-m", "first"]);
    let bucket = tmp.path().join("bucket");
    let url = format!("dir://{}", bucket.display());

    // Store settings belong to bucket URLs only, and are kept on the URL.
    let (code, _, err) = oxy(
        &a,
        &home,
        &["remote", "add", "usb", &url, "--profile", "work"],
    );
    assert_ne!(code, 0);
    assert!(err.contains("--profile") && err.contains("s3://"), "{err}");
    ok(
        &a,
        &home,
        &[
            "remote",
            "add",
            "cloud",
            "s3://my-bucket/repos/a",
            "--profile",
            "work",
            "--region",
            "eu-west-2",
        ],
    );
    let listed = ok(&a, &home, &["remote", "list"]);
    assert!(
        listed.contains("s3://my-bucket/repos/a?profile=work&region=eu-west-2"),
        "{listed}"
    );
    ok(&a, &home, &["remote", "remove", "cloud"]);

    // A directory store: check before anything is there, push, check again.
    ok(&a, &home, &["remote", "add", "usb", &url]);
    let out = ok(&a, &home, &["remote", "check", "usb"]);
    assert!(
        out.contains("Reachable")
            && out.contains("holds no repository yet")
            && out.contains("Behaves"),
        "{out}"
    );
    assert_eq!(
        std::fs::read_dir(&bucket).unwrap().count(),
        0,
        "the check left nothing behind"
    );
    ok(&a, &home, &["push", "usb"]);
    let out = ok(&a, &home, &["remote", "check", "usb"]);
    assert!(
        out.contains("holds this repository")
            && out.contains("1 bookmark")
            && out.contains("1 bundle")
            && out.contains("Behaves"),
        "{out}"
    );

    // Clone from the store, push back, pull.
    let b = tmp.path().join("b");
    ok(tmp.path(), &home, &["clone", &url, b.to_str().unwrap()]);
    assert_eq!(std::fs::read_to_string(b.join("f.txt")).unwrap(), "hello\n");
    std::fs::write(b.join("f.txt"), "hello\nagain\n").unwrap();
    ok(&b, &home, &["commit", "-m", "second"]);
    ok(&b, &home, &["push"]);
    ok(&a, &home, &["pull", "usb"]);
    assert_eq!(
        std::fs::read_to_string(a.join("f.txt")).unwrap(),
        "hello\nagain\n"
    );

    // Two pushes made two bundles; a gc folds them into one, and a clone
    // after it is whole.
    let out = ok(&a, &home, &["gc", "--remote", "usb", "--now"]);
    assert!(
        out.contains("Folded 2 bundles") && out.contains("removed 2 superseded bundles"),
        "{out}"
    );
    assert_eq!(
        std::fs::read_dir(bucket.join("bundles")).unwrap().count(),
        1
    );
    let d = tmp.path().join("d");
    ok(tmp.path(), &home, &["clone", &url, d.to_str().unwrap()]);
    assert_eq!(
        std::fs::read_to_string(d.join("f.txt")).unwrap(),
        "hello\nagain\n"
    );
    let (code, _, err) = oxy(&a, &home, &["gc", "--remote", "nope"]);
    assert_ne!(code, 0);
    assert!(err.contains("no remote"), "{err}");

    // Another repository is told the store is taken.
    let c = tmp.path().join("c");
    ok(tmp.path(), &home, &["init", c.to_str().unwrap()]);
    std::fs::write(c.join("g.txt"), "other\n").unwrap();
    ok(&c, &home, &["commit", "-m", "mine"]);
    ok(&c, &home, &["remote", "add", "usb", &url]);
    let out = ok(&c, &home, &["remote", "check", "usb"]);
    assert!(
        out.contains("holds another repository") && out.contains("would be refused"),
        "{out}"
    );
    let (code, _, err) = oxy(&c, &home, &["push", "usb"]);
    assert_ne!(code, 0);
    assert!(err.contains("different repository"), "{err}");
}

#[test]
fn commit_with_paths_says_what_it_left() {
    let tmp = tempfile::tempdir().unwrap();
    let home = tmp.path().join("home");
    std::fs::create_dir_all(&home).unwrap();
    let a = tmp.path().join("a");
    ok(tmp.path(), &home, &["init", a.to_str().unwrap()]);
    std::fs::write(a.join("f.txt"), "one\n").unwrap();
    std::fs::write(a.join("g.txt"), "one\n").unwrap();
    ok(&a, &home, &["commit", "-m", "first"]);

    std::fs::write(a.join("f.txt"), "two\n").unwrap();
    std::fs::write(a.join("g.txt"), "two\n").unwrap();
    let part = ok(&a, &home, &["commit", "-m", "f only", "f.txt"]);
    assert!(part.contains("1 path left uncommitted"), "{part}");

    let rest = ok(&a, &home, &["commit", "-m", "g", "g.txt"]);
    assert!(!rest.contains("left uncommitted"), "{rest}");
    let status = ok(&a, &home, &["status"]);
    assert!(status.contains("working copy clean"), "{status}");
}