fn as_solver_limit(self) -> i32 {

        match self {

            NumberOfSolutions::All => 0,

            NumberOfSolutions::Limit(limit) => limit,

    }

fn parse_number_of_solutions(input: &str) -> Result<NumberOfSolutions, String> {

    if input.eq_ignore_ascii_case("all") {

        return Ok(NumberOfSolutions::All);

    }

    let limit = input

        .parse::<i32>()

    if limit <= 0 {

    }

    Ok(NumberOfSolutions::Limit(limit))

}

pub fn run_solve_command(global_args: GlobalArgs, solve_args: Args) -> anyhow::Result<()> {

    let essence_file = solve_args.essence_file.clone();

    let param_file = solve_args.param_file.clone();

    let context = init_context(&global_args, essence_file, param_file)?;

    let ctx_lock = context.read().unwrap();

    let essence_file_name = ctx_lock

        .essence_file_name

        .as_ref()

        .expect("context should contain the problem input file");

    let param_file_name = ctx_lock.param_file_name.as_ref();

    let problem_model = parse(&global_args, Arc::clone(&context), essence_file_name)?;

    let unified_model = match param_file_name {

            let param_model = parse_param(

                &global_args,

                Arc::clone(&context),

                param_file_name,

                &problem_model,

            )?;

            instantiate_model(problem_model, param_model)?

            let mut problem_model = problem_model;

            validate_instantiation_conditions(&mut problem_model)?;

            problem_model

    drop(ctx_lock);

    let rewritten_model = rewrite(unified_model, &global_args, Arc::clone(&context))?;

    let solver = init_solver(&global_args)?;

    if solve_args.no_run_solver {

        println!("{}", rewritten_model);

        if let Some(path) = global_args.save_solver_input_file {

        }

        run_solver(solver, &global_args, &solve_args, rewritten_model)?

    if let Some(ref path) = solve_args.info_json_path {

    }

    Ok(())

}

pub(crate) fn init_context(

    global_args: &GlobalArgs,

    essence_file: PathBuf,

    param_file: Option<PathBuf>,

) -> anyhow::Result<Arc<RwLock<Context<'static>>>> {

    let default_rule_trace_enabled = global_args.rule_trace.is_some();

    let rule_attempt_trace_enabled = global_args.rule_attempt_trace.is_some();

    let rule_trace_aggregates_enabled = global_args.rule_trace_aggregates.is_some();

        default_rule_trace_enabled || rule_attempt_trace_enabled || rule_trace_aggregates_enabled;

    set_current_parser(global_args.parser);

    set_current_rewriter(global_args.rewriter);

    set_comprehension_expander(global_args.comprehension_expander);

    set_current_solver_family(global_args.solver);

    set_minion_discrete_threshold(global_args.minion_discrete_threshold);

    set_rule_trace_enabled(rule_trace_enabled);

    set_default_rule_trace_enabled(default_rule_trace_enabled);

    set_rule_attempt_trace_enabled(rule_attempt_trace_enabled);

    set_rule_trace_aggregates_enabled(rule_trace_aggregates_enabled);

    let target_family = global_args.solver;

    let mut extra_rule_sets: Vec<&str> = DEFAULT_RULE_SETS.to_vec();

    for rs in &global_args.extra_rule_sets {

    let rule_sets = match resolve_rule_sets(target_family, &extra_rule_sets) {

        Ok(rs) => rs,

    tracing::info!(

        count = rule_sets.len(),

        "resolved rule sets"

        rule_sets = %rule_sets

            .iter()

            .map(|rule_set| rule_set.name)

            .join(", "),

        "enabled rule sets"

    let rules = get_rules(&rule_sets)?.into_iter().collect::<Vec<_>>();

        rules

            .iter()

            .map(|rd| format!("{rd}"))

            .join("\n")

    let context = Context::new_ptr(

        target_family,

        extra_rule_sets.iter().map(|rs| rs.to_string()).collect(),

        rules,

        rule_sets.clone(),

    context.write().unwrap().essence_file_name = Some(essence_file.to_str().expect("").into());

    if let Some(param_file) = param_file {

        context.write().unwrap().param_file_name = Some(param_file.to_str().expect("").into());

    }

    Ok(context)

}

pub(crate) fn init_solver(global_args: &GlobalArgs) -> anyhow::Result<Solver> {

    let family = global_args.solver;

    let timeout = global_args.solver_timeout.map(Duration::from);

    Ok(match family {

        SolverFamily::Minion => Solver::new(

            Minion::with_search_orders(global_args.minion_varorder, global_args.minion_valorder)

                .with_solver_seed(global_args.solver_seed)

                .with_timeout(timeout),

        ),

        SolverFamily::Sat => Solver::new(

            Sat::new(global_args.sat_backend)

                .with_solver_seed(global_args.solver_seed)

                .with_timeout(timeout),

        ),

            Solver::new(Smt::new(timeout).with_solver_seed(global_args.solver_seed))

}

pub(crate) fn parse(

    global_args: &GlobalArgs,

    context: Arc<RwLock<Context<'static>>>,

    file_path: &str,

) -> anyhow::Result<Model> {

    tracing::info!(target: "conjure::stage", path = %file_path, "parsing input model");

    match global_args.parser {

            parse_essence_file_native(file_path, context.clone()).map_err(|e| e.into())

        conjure_cp::settings::Parser::ViaConjure => parse_with_conjure(file_path, context.clone()),

}

pub(crate) fn parse_param(

    global_args: &GlobalArgs,

    context: Arc<RwLock<Context<'static>>>,

    file_path: &str,

    problem_model: &Model,

) -> anyhow::Result<Model> {

    if file_path.ends_with(".json") {

    }

    parse(global_args, context, file_path)

}

pub(crate) fn parse_with_conjure(

    input_file: &str,

    context: Arc<RwLock<Context<'static>>>,

) -> anyhow::Result<Model> {

    conjure_executable().map_err(|e| anyhow!("Could not find correct conjure executable: {e}"))?;

    let mut cmd = std::process::Command::new("conjure");

    let output = cmd

        .arg("pretty")

        .arg("--output-format=astjson")

        .arg(input_file)

        .output()?;

    if !output.status.success() {

    }

    let astjson = String::from_utf8(output.stdout)?;

    if cfg!(feature = "extra-rule-checks") {

    model_from_json(&astjson, context.clone()).map_err(|e| anyhow!(e))

}

pub(crate) fn rewrite(

    model: Model,

    global_args: &GlobalArgs,

    context: Arc<RwLock<Context<'static>>>,

) -> anyhow::Result<Model> {

    let rewriter = global_args.rewriter;

    set_current_rewriter(rewriter);

    let comprehension_expander = global_args.comprehension_expander;

    set_comprehension_expander(comprehension_expander);

    set_heuristic(global_args.heuristic);

    set_heuristic_seed(global_args.seed);

    set_heuristic_responses(global_args.responses.clone());

    set_channelling(global_args.channelling);

    conjure_cp::settings::set_amo_encoding(global_args.amo_encoding);

    conjure_cp::settings::set_pb_encoding(global_args.pb_encoding);

    conjure_cp::settings::set_element_encoding(global_args.element_encoding);

    conjure_cp::settings::set_table_encoding(global_args.table_encoding);

    conjure_cp::settings::set_alldifferent_encoding(global_args.alldifferent_encoding);

    conjure_cp::settings::set_cardinality_encoding(global_args.cardinality_encoding);

        global_args.heuristic,

        global_args.seed,

        global_args.responses,

        global_args.channelling,

        global_args.solver_seed

    let rule_sets = context.read().unwrap().rule_sets.clone();

    let Rewriter::Rewrite(config) = rewriter;

    tracing::info!(target: "conjure::stage", %config, "rewriting model");

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

    Ok(new_model)

}

fn run_solver(

    solver: Solver,

    global_args: &GlobalArgs,

    cmd_args: &Args,

    model: Model,

) -> anyhow::Result<()> {

    let domains = domains_from_model(&model);

    let solutions = get_solutions(

        solver,

        model,

        cmd_args.number_of_solutions.as_solver_limit(),

        cmd_args.keep_intermediate_solutions,

        &global_args.save_solver_input_file,

        global_args.rule_trace_cdp,

    )?;

    let solutions = coerce_bools_in_solutions(&solutions, &domains);

    write_solutions(&solutions, cmd_args)?;

    Ok(())

}

fn coerce_bools_in_solutions(

    solutions: &[std::collections::BTreeMap<conjure_cp::ast::Name, conjure_cp::ast::Literal>],

    domains: &std::collections::BTreeMap<conjure_cp::ast::Name, conjure_cp::ast::DomainPtr>,

) -> Vec<std::collections::BTreeMap<conjure_cp::ast::Name, conjure_cp::ast::Literal>> {

    solutions

        .iter()

        .map(|solution| {

            solution

                .iter()

                .map(|(name, value)| {

                    let value = match domains.get(name).and_then(|domain| domain.as_ground()) {

                        Some(GroundDomain::Bool) => match value {

                            Literal::Int(1) => Literal::Bool(true),

                            Literal::Int(0) => Literal::Bool(false),

                            other => other.clone(),

                        _ => value.clone(),

                    (name.clone(), value)

                })

        })

}

fn write_solutions(

    solutions: &[std::collections::BTreeMap<conjure_cp::ast::Name, conjure_cp::ast::Literal>],

    cmd_args: &Args,

) -> anyhow::Result<()> {

    if cmd_args.solutions_in_one_file {

        let body = match cmd_args.output_format {

            OutputFormat::Essence => solutions_to_essence(solutions),

        match &cmd_args.output {

            None => print!("{body}"),

        return Ok(());

}