fn run_case_label(

    path: &str,

    essence_base: &str,

    extension: &str,

    run_case: RunCase<'_>,

) -> String {

    format!(

        run_case.solver.as_str()

}

fn integration_test(path: &str, essence_base: &str, extension: &str) -> Result<(), Box<dyn Error>> {

    let accept_mode = AcceptMode::from_env();

    let accept = accept_mode.accepts_outputs();

    let started_at = Instant::now();

    if accept {

    }

    let file_config: TestConfig =

        if let Ok(config_contents) = fs::read_to_string(format!("{path}/config.toml")) {

            toml::from_str(&config_contents).unwrap()

    let config = file_config;

    let validate_with_conjure = config.validate_with_conjure;

    let minion_discrete_threshold = config.minion_discrete_threshold;

    let parsers = config

        .configured_parsers()

        .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?;

    let rewriters = config

        .configured_rewriters()

        .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?;

    let comprehension_expanders = config

        .configured_comprehension_expanders()

        .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?;

    let solvers = config

        .configured_solvers()

        .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))?;

    let model_path = format!("{path}/{essence_base}.{extension}");

    let conjure_solutions = if accept && validate_with_conjure {

        if accept && !validate_with_conjure {

        }

        None

    let mut allowed_expected_files = BTreeSet::new();

    for parser in parsers.iter().copied() {

        for rewriter in rewriters.clone() {

            for comprehension_expander in comprehension_expanders.clone() {

                for solver in solvers.clone() {

                    let case_name = run_case_name(parser, rewriter, comprehension_expander);

                    let run_case = RunCase {

                        parser,

                        rewriter,

                        comprehension_expander,

                        solver,

                        case_name: case_name.as_str(),

                    };

                    let file = File::create(format!(

                        run_case.solver.as_str()

                    let subscriber = Arc::new(

                        tracing_subscriber::registry().with(

                            fmt::layer()

                                .with_writer(file)

                                .with_level(false)

                                .without_time()

                                .with_target(false)

                                .with_filter(EnvFilter::new("rule_engine_rule_trace=trace"))

                                .with_filter(FilterFn::new(|meta| {

                                    meta.target() == "rule_engine_rule_trace"

                                })),

                        as Arc<dyn tracing::Subscriber + Send + Sync>;

                    let run_label = run_case_label(path, essence_base, extension, run_case);

                    eprintln!("[integration] running {run_label}");

                    let default_rule_trace_enabled = matches!(rewriter, Rewriter::Naive);

                    set_rule_trace_enabled(true);

                    set_default_rule_trace_enabled(default_rule_trace_enabled);

                    set_rule_trace_verbose_enabled(false);

                    set_rule_trace_aggregates_enabled(false);

                    tracing::subscriber::with_default(subscriber, || {

                        integration_test_inner(

                            path,

                            essence_base,

                            extension,

                            run_case,

                            minion_discrete_threshold,

                            conjure_solutions.clone(),

                            accept,

                    })

                    .map_err(|err| std::io::Error::other(format!("{run_label}: {err}")))?;

                    allowed_expected_files.extend(expected_integration_files_for_case(

                        run_case.case_name,

                        solver,

    assert_no_redundant_expected_files(Path::new(path), &allowed_expected_files, None)?;

    if accept_mode.records_expected_time() {

    }

    Ok(())

}

fn integration_test_inner(

    path: &str,

    essence_base: &str,

    extension: &str,

    run_case: RunCase<'_>,

    minion_discrete_threshold: usize,

    conjure_solutions: Option<Arc<Vec<BTreeMap<Name, Literal>>>>,

    accept: bool,

) -> Result<(), Box<dyn Error>> {

    let parser = run_case.parser;

    let rewriter = run_case.rewriter;

    let comprehension_expander = run_case.comprehension_expander;

    let solver_fam = run_case.solver;

    let case_name = run_case.case_name;

    let context: Arc<RwLock<Context<'static>>> = Default::default();

    set_current_parser(parser);

    set_current_rewriter(rewriter);

    set_comprehension_expander(comprehension_expander);

    set_current_solver_family(solver_fam);

    set_minion_discrete_threshold(minion_discrete_threshold);

    let file_path = format!("{path}/{essence_base}.{extension}");

    let parsed_model = match parser {

            let mut ctx = context.as_ref().write().unwrap();

            ctx.essence_file_name = Some(format!("{path}/{essence_base}.{extension}"));

            parse_essence_file_native(&file_path, context.clone())?

        Parser::ViaConjure => parse_essence_file(&file_path, context.clone())?,

    let mut extra_rules = vec![];

    if let SolverFamily::Sat(sat_encoding) = solver_fam {

        extra_rules.push(sat_encoding.as_rule_set());

    }

    let mut rules_to_load = DEFAULT_RULE_SETS.to_vec();

    rules_to_load.extend(extra_rules);

    let rule_sets = resolve_rule_sets(solver_fam, &rules_to_load)?;

    let model = parsed_model;

    let rewritten_model = match rewriter {

        Rewriter::Naive => rewrite_naive(&model, &rule_sets, false)?,

        Rewriter::Morph(config) => rewrite_morph(model, &rule_sets, false, config),

    let solver_input_file = None;

    let solver = match solver_fam {

        SolverFamily::Minion => Solver::new(Minion::default()),

        SolverFamily::Sat(_) => Solver::new(Sat::default()),

        SolverFamily::Smt(_) => Solver::new(Smt::default()),

    let solutions = {

        let solved = get_solutions(solver, rewritten_model, 0, &solver_input_file, false)?;

        save_solutions_json(&solved, path, case_name, solver_fam)?;

        solved

    if accept && conjure_solutions.is_some() {

    }

    if accept {

    }

    let expected_solutions_json = read_solutions_json(path, case_name, "expected", solver_fam)?;

    let username_solutions_json = solutions_to_json(&solutions);

    assert_eq!(username_solutions_json, expected_solutions_json);

    match rewriter {

        Rewriter::Morph(_) => {}

            let generated = read_default_rule_trace(path, case_name, "generated", &solver_fam)?;

            let expected = read_default_rule_trace(path, case_name, "expected", &solver_fam)?;

            assert_eq!(

    save_stats_json(context, path, case_name, solver_fam)?;

    Ok(())

}

fn run_case_name(

    parser: Parser,

    rewriter: Rewriter,

    comprehension_expander: QuantifiedExpander,

) -> String {

    format!("{parser}-{rewriter}-{comprehension_expander}")

}

fn expected_integration_files_for_case(case_name: &str, solver: SolverFamily) -> BTreeSet<String> {

    let solver_name = solver.as_str();

    BTreeSet::from([

        format!("{case_name}-{solver_name}.expected-solutions.json"),

        format!("{case_name}-{solver_name}-expected-rule-trace.txt"),

    ])

}

fn assert_conjure_present() {

    conjure_cp_cli::find_conjure::conjure_executable().unwrap();

}