use super::checked;

const HANDLERS: &str = "double(value: Int) (answer: Int) { answer = value * 2 }\npositive(value: Int) (answer: Bool) { answer = value > 0 }\nadd(value: Int, state: Int) (next: Int) { next = value + state }\nstop(value: Int, state: Int) (next: Int, stop: Bool) { next = value + state\n stop = next >= 3 }\n";
const ERRORS: &str = "type Result { Ready(value: Int)\n error Failed(message: Text) }\nidentity(value: Result) (answer: Result) { answer = value }\nhandled(value: Result) (answer: Bool) recover(\"optional probe failure is explicitly discarded\") { answer = true }\ncontext(value: Int, state: Result) () recover(\"optional context probe is discarded\") {}\nkeep(value: Int, state: Result) (next: Result) { next = state }\nconsume(value: Result, state: Int) (next: Int) recover(\"count failed probes\") { next = state + 1 }\npartial(value: Result, state: Int) (next: Int, stop: Bool) recover(\"count failed probes\") { next = state + 1\n stop = true }\n";

#[test]
fn checks_collection_handler_types_and_cycles() {
    for body in [
        "main() (answer: List<Int>) { answer = each(double, []) }",
        "main() (answer: List<Int>) { answer = filter(positive, [1, -1]) }",
        "main() (answer: Int?) { answer = find(positive, []) }",
        "main() (answer: Int) { answer = sum(double, []) }",
        "main() (answer: Float) { answer = sum([]) }",
        "main() (answer: Decimal?) { answer = sum([]) }",
        "main() (answer: Int) { answer = reduce(add, [], 10) }",
        "main() (answer: Int) { answer = reduceUntil(stop, [1, 2, 3], 0) }",
    ] {
        let result = checked(&(HANDLERS.to_owned() + body));
        assert!(result.is_ok(), "{body}: {result:?}");
    }
    for body in [
        "main() (answer: List<Int>) { answer = each(positive, [1]) }",
        "main() (answer: List<Int>) { answer = filter(double, [1]) }",
        "main() (answer: Int?) { answer = find(positive, [\"one\"]) }",
        "main() (answer: Int) { answer = sum(positive, [1]) }",
        "main() (answer: Int) { answer = reduce(add, [1], true) }",
        "main() (answer: Int) { answer = reduceUntil(add, [1], 0) }",
        "main() (answer: Int) { answer = reduce(add, [1], 0, 1) }",
        "main() (answer: List<Int>) { double = 2\n answer = each(double, [1]) }",
        "main() () { handler = double }",
    ] {
        assert!(checked(&(HANDLERS.to_owned() + body)).is_err(), "{body}");
    }
    assert_eq!(
        checked("cycle(value: Int) (answer: Int) { answer = sum(cycle, [value]) }")
            .unwrap_err()
            .code,
        "C007"
    );
    assert_eq!(checked("first(value: Int) (answer: Int) { answer = sum(second, [value]) }\nsecond(value: Int) (answer: Int) { answer = first(value) }").unwrap_err().code, "C007");
}

#[test]
fn collections_preserve_error_obligations() {
    for body in [
        "main(values: List<Result>) (answer: Int) { copies = each(identity, values)\n answer = length(copies) }",
        "main(values: List<Result>) (answer: Result?) { answer = find(handled, values) }",
        "main(values: List<Result>) (answer: Int) { answer = reduceUntil(partial, values, 0) }",
        "main() (answer: Int) { answer = reduceUntil(partial, [Result.Failed(\"one\"), Result.Failed(\"two\")], 0) }",
        "main(state: Result) () { each(context, [], state) }",
        "main(values: List<Int>, state: Result) () { each(context, values, state) }",
        "main(state: Result) (answer: Int) { kept = reduce(keep, [], state)\n answer = 1 }",
        "main() (answer: List<Result>) { lost = Result.Failed(\"lost\")\n answer = each(identity, []) }",
    ] {
        let result = checked(&(ERRORS.to_owned() + body));
        assert_eq!(result.unwrap_err().code, "C012", "{body}");
    }
    for body in [
        "main(values: List<Result>) (answer: List<Result>) { answer = each(identity, values) }",
        "main(values: List<Result>) (answer: Int) { answer = reduce(consume, values, 0) }",
        "main(state: Result) () { each(context, [1], state) }",
        "main() (answer: Result?) { answer = find(handled, [Result.Failed(\"one\")]) }",
        "main() (answer: Int) { answer = reduceUntil(partial, [Result.Failed(\"one\")], 0) }",
        "main(state: Result) (answer: Result) { answer = reduce(keep, [], state) }",
    ] {
        let result = checked(&(ERRORS.to_owned() + body));
        assert!(result.is_ok(), "{body}: {result:?}");
    }
}

#[test]
fn collection_error_summaries_survive_calls_and_repeated_state() {
    let prefix = ERRORS.to_owned()
        + "copy(values: List<Result>) (answer: List<Result>) { answer = each(identity, values) }\nreplace(value: Result, state: Result) (next: Result) recover(\"last probe replaces previous probe\") { next = value }\n";
    for body in [
        "main(values: List<Result>) (answer: Int) { copies = copy(values)\n answer = length(copies) }",
        "main(values: List<Result>, state: Result) (answer: Int) { last = reduce(replace, values, state)\n answer = 1 }",
        "main(state: Result) () { copies = copy([])\n count = length(copies) }",
    ] {
        assert_eq!(
            checked(&(prefix.clone() + body)).unwrap_err().code,
            "C012",
            "{body}"
        );
    }
    let source = prefix
        + "main(values: List<Result>, state: Result) (answer: Result) { answer = reduce(replace, values, state) }";
    assert!(checked(&source).is_ok());
}

#[test]
fn optional_traversal_cannot_transfer_unvisited_obligations() {
    let prefix = ERRORS.to_owned()
        + "takeContext(value: Int, context: Result) (answer: Result) { answer = context }\nfirst(value: Result, state: Result) (next: Result, stop: Bool) recover(\"replace previous state\") { next = value\n stop = true }\n";
    for body in [
        "main(values: List<Int>, state: Result) (answer: List<Result>) { answer = each(takeContext, values, state) }",
        "main(values: List<Result>) (answer: Result) { answer = reduceUntil(first, values, Result.Ready(0)) }",
    ] {
        assert_eq!(
            checked(&(prefix.clone() + body)).unwrap_err().code,
            "C012",
            "{body}"
        );
    }
    assert!(checked(&(prefix + "main(state: Result) (answer: List<Result>) { answer = each(takeContext, [1], state) }")).is_ok());
}

#[test]
fn replacing_record_fields_still_checks_discarded_failures() {
    let source = ERRORS.to_owned()
        + "type Row { result: Result\n count: Int }\nreplace(value: Row) (answer: Row) { answer = value\n answer.result = Result.Ready(1)\n answer.count = 0 }";
    assert_eq!(checked(&source).unwrap_err().code, "C012");
}

#[test]
fn known_length_map_builds_reserve_once_and_update_in_place() {
    for (kind, item, value, sequence) in [
        ("Bytes", "Int", "value", "values"),
        ("List<Int>", "Int", "value", "values"),
        (
            "Map<Int, Int>",
            "MapEntry<Int, Int>",
            "value.value",
            "entries(values)",
        ),
    ] {
        let text = format!(
            "insert(value: {item}, state: Map<Int, Int>) (next: Map<Int, Int>) {{ next = put(state, length(state), {value}) }}\nmain(values: {kind}) (answer: Map<Int, Int>) {{ answer = reduce(insert, {sequence}, {{}}) }}"
        );
        let source = dever::syntax::source::Source::new(0, "case.dever", text);
        let program = checked(&source.text).unwrap();
        let generated = dever::compiler::emit::generate(&program, &[source], &[1].into());
        let main = generated.split("pub fn function1(").nth(1).unwrap();
        let main = main.split("pub fn ").next().unwrap();
        assert!(
            main.contains("Map::with_capacity(sequence.len())"),
            "{main}"
        );
        assert!(main.contains("state.insert("), "{main}");
        assert!(!main.contains("state.clone()"), "{main}");
        assert!(!main.contains(".to_owned()"), "{main}");
    }
}

#[test]
fn record_reductions_keep_a_single_growing_buffer() {
    let text = "type State { values: List<Int>\n count: Int }\nstep(value: Int, state: State) (next: State) { values = append(state.values, value)\n next = State { values = values\n count = state.count + 1 } }\nmain(input: Bytes) (answer: State) { answer = reduce(step, input, State { values = []\n count = 0 }) }";
    let source = dever::syntax::source::Source::new(0, "case.dever", text.into());
    let program = checked(text).unwrap();
    let generated = dever::compiler::emit::generate(&program, &[source], &[1].into());
    let main = generated.split("pub fn function1(").nth(1).unwrap();
    let main = main.split("\npub ").next().unwrap();
    assert!(!main.contains(".clone()"), "{main}");
    let iteration = main.split("for byte in sequence").nth(1).unwrap();
    let iteration = iteration.split("Type0 {").next().unwrap();
    assert!(!iteration.contains(".reserve("), "{main}");
    assert!(iteration.contains(".push(element)"), "{main}");
}

#[test]
fn map_selection_copies_only_matching_entries() {
    for (operation, result) in [
        ("filter", "List<MapEntry<Text, Text>>"),
        ("find", "MapEntry<Text, Text>?"),
    ] {
        let text = format!(
            "matches(entry: MapEntry<Text, Text>, target: Text) (answer: Bool) {{ answer = entry.value == target }}\nmain(values: Map<Text, Text>, target: Text) (answer: {result}) {{ answer = {operation}(matches, entries(values), target) }}"
        );
        let source = dever::syntax::source::Source::new(0, "case.dever", text.clone());
        let program = checked(&text).unwrap();
        let generated = dever::compiler::emit::generate(&program, &[source], &[1].into());
        let main = generated.split("pub fn function1(").nth(1).unwrap();
        let main = main.split("\npub ").next().unwrap();
        let iteration = main.split("for (key, value) in sequence").nth(1).unwrap();
        let (inspection, selected) = iteration.split_once("if ").unwrap();
        assert!(!inspection.contains(".clone()"), "{main}");
        assert!(selected.contains("(key.clone(), value.clone())"), "{main}");
    }
}