#[derive(Deserialize, Default)]

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

    let verbose = env::var("VERBOSE").unwrap_or("false".to_string()) == "true";

    // Lock here to ensure sequential execution

    let _guard = GUARD.lock().unwrap();

    // run tests in sequence not parallel when verbose logging, to ensure the logs are ordered

    // correctly

    let (subscriber, _guard) = create_scoped_subscriber(path, essence_base);

    // set the subscriber as default

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

        let test_span = span!(target: "rule_engine", Level::TRACE, "test_span");

        let _enter = test_span.enter();

        // execute tests based on verbosity

        if verbose {

            integration_test_inner(path, essence_base, extension)?

        Ok(())

    })

}

fn integration_test_inner(

    path: &str,

    essence_base: &str,

    extension: &str,

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

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

    let accept = env::var("ACCEPT").unwrap_or("false".to_string()) == "true";

    let verbose = env::var("VERBOSE").unwrap_or("false".to_string()) == "true";

    if verbose {

    }

    let config: TestConfig =

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

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

            Default::default()

    let model = parse_essence_file(path, essence_base, extension, context.clone())?;

    if verbose {

    }

    context.as_ref().write().unwrap().file_name =

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

    save_model_json(&model, path, essence_base, "parse", accept)?;

    let expected_model = read_model_json(path, essence_base, "expected", "parse")?;

    if verbose {

    }

    assert_eq!(model, expected_model);

    let rule_sets = resolve_rule_sets(SolverFamily::Minion, &get_default_rule_sets())?;

    let model = rewrite_model(&model, &rule_sets)?;

    if verbose {

    }

    save_model_json(&model, path, essence_base, "rewrite", accept)?;

    for extra_assert in config.extra_rewriter_asserts {

        match extra_assert.as_str() {

            "vector_operators_have_partially_evaluated" => {

                assert_vector_operators_have_partially_evaluated(&model)

    let expected_model = read_model_json(path, essence_base, "expected", "rewrite")?;

    if verbose {

    }

    assert_eq!(model, expected_model);

    let solutions = get_minion_solutions(model)?;

    let solutions_json = save_minion_solutions_json(&solutions, path, essence_base, accept)?;

    if verbose {

    }

    let expected_rule_trace = read_rule_trace(path, essence_base, "expected")?;

    let generated_rule_trace = read_rule_trace(path, essence_base, "generated")?;

    assert_eq!(expected_rule_trace, generated_rule_trace);

    if accept {

    }

    let expected_solutions_json = read_minion_solutions_json(path, essence_base, "expected")?;

    if verbose {

    }

    assert_eq!(solutions_json, expected_solutions_json);

    save_stats_json(context, path, essence_base)?;

    Ok(())

}

fn assert_vector_operators_have_partially_evaluated(model: &conjure_core::Model) {

    model.constraints.transform(Arc::new(|x| {

        match &x {

            Atomic(_, _) => (),

            Or(_, vec) => assert_constants_leq_one(&x, vec),

            And(_, vec) => assert_constants_leq_one(&x, vec),

            Eq(_, _, _) => (),

            SumGeq(_, vec, _) => assert_constants_leq_one(&x, vec),

            SumLeq(_, vec, _) => assert_constants_leq_one(&x, vec),

            Ineq(_, _, _, _) => (),

            WatchedLiteral(_, _, _) => (),

        x.clone()

    }));

}

fn assert_constants_leq_one(parent_expr: &Expression, exprs: &[Expression]) {

    let count = exprs.iter().fold(0, |i, x| match x {

        _ => i,

    });

    assert!(count <= 1, "assert_vector_operators_have_partially_evaluated: expression {} is not partially evaluated",parent_expr)

}

    fn format_event(

        &self,

        _ctx: &FmtContext<'_, S, N>,

        mut writer: Writer<'_>,

        event: &Event<'_>,

    ) -> std::fmt::Result {

        // initialising the log object with level and target

        let mut log = json!({

            //"level": event.metadata().level().to_string(),

            "target": event.metadata().target(),

        });

            fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {

                self.log

                    .as_object_mut()

                    .map(|obj| obj.insert(field.name().to_string(), json!(format!("{:?}", value))));

            }

        let mut visitor = JsonVisitor { log: log.clone() };

        event.record(&mut visitor);

        // merging the visitor's log into the main log object

        log.as_object_mut().map(|obj| {

            if let Some(visitor_obj) = visitor.log.as_object() {

                for (key, value) in visitor_obj {

                    obj.insert(key.clone(), value.clone());

                }

        });

        // Write the JSON log

        write!(writer, "{}\n", log)

    }

pub fn create_scoped_subscriber(

    path: &str,

    test_name: &str,

) -> (impl tracing::Subscriber + Send + Sync, WorkerGuard) {

    let file = File::create(format!("{path}/{test_name}-generated-rule-trace.json"))

        .expect("Unable to create log file");

    let writer = BufWriter::new(file);

    let (non_blocking, guard) = tracing_appender::non_blocking(writer);

    // subscriber setup with the JSON formatter

    let subscriber = Registry::default()

        .with(EnvFilter::new("rule_engine=trace"))

        .with(

            fmt::layer()

                .with_writer(non_blocking)

                .json()

                .event_format(JsonFormatter),

        );

    // wrapping the subscriber in an Arc to share across multiple threads

    let subscriber = Arc::new(subscriber) as Arc<dyn tracing::Subscriber + Send + Sync>;

    // setting this subscriber as the default

    let _default = tracing::subscriber::set_default(subscriber.clone());

    (subscriber, guard)

}

fn assert_conjure_present() {

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

}