use super::{Directory, fixture};
use dever::compiler::{build, project::Project};

#[test]
fn bytes_preserve_utf8_bounds_failures_and_traversal_order() {
    let directory = Directory::new();
    let project = Project::load(&fixture().with_file_name("bytes.dever")).unwrap();
    let program = project.check().unwrap();
    for (entry, expected) in [
        ("verify", None),
        (
            "joinedSeedErrorEntry",
            Some((
                "lib/dever/bytes.dever",
                "BufferResult.Failed",
                "fail(BufferResult.Failed(message))",
            )),
        ),
        (
            "concatArgumentEntry",
            Some((
                "lib/dever/bytes.dever",
                "BufferResult.Failed",
                "fail(BufferResult.Failed(message))",
            )),
        ),
        (
            "concatLeftErrorEntry",
            Some((
                "lib/dever/bytes.dever",
                "DecodeResult.Failed",
                "fail(DecodeResult.Failed(message))",
            )),
        ),
        (
            "invalidEntry",
            Some((
                "lib/dever/bytes.dever",
                "DecodeResult.Failed",
                "fail(DecodeResult.Failed(message))",
            )),
        ),
        (
            "invalidListEntry",
            Some((
                "lib/dever/bytes.dever",
                "DecodeResult.Failed",
                "fail(DecodeResult.Failed(message))",
            )),
        ),
        (
            "overflowEntry",
            Some((
                "test/rust/fixtures/bytes.dever",
                "integer arithmetic fault",
                "state + item",
            )),
        ),
        (
            "argumentEntry",
            Some((
                "lib/dever/bytes.dever",
                "BufferResult.Failed",
                "fail(BufferResult.Failed(message))",
            )),
        ),
    ] {
        let binary =
            build::build(&program, &project.sources, entry, &directory.0.join(entry)).unwrap();
        let output = std::process::Command::new(binary).output().unwrap();
        if let Some((source, message, needle)) = expected {
            assert!(!output.status.success());
            assert!(output.stdout.is_empty());
            let stderr = String::from_utf8(output.stderr).unwrap();
            let source = project
                .sources
                .iter()
                .find(|item| item.path.ends_with(source))
                .unwrap();
            let offset = source.text.find(needle).unwrap();
            let offset = if needle.starts_with("fail(") {
                offset + 5
            } else {
                offset
            };
            let (line, column) = source.position(offset);
            assert!(stderr.contains(message), "{stderr}");
            assert!(
                stderr.contains(&format!("{}:{line}:{column}:", source.path.display())),
                "{stderr}"
            );
        } else {
            assert!(
                output.status.success(),
                "{}",
                String::from_utf8_lossy(&output.stderr)
            );
            assert_eq!(output.stdout, b"true\n");
        }
    }
}

#[test]
fn literal_prefix_evaluates_the_suffix_once() {
    let directory = Directory::new();
    let project = Project::load(&fixture().with_file_name("bytes.dever")).unwrap();
    let program = project.check().unwrap();
    let binary = build::build(
        &program,
        &project.sources,
        "concatOrderEntry",
        &directory.0.join("concat-order"),
    )
    .unwrap();
    let output = std::process::Command::new(binary).output().unwrap();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(output.stdout, b"suffix\ntrue\n");
}