input_file: PathBuf,

    extra_rule_sets: Vec<String>,

        default_value_t = false,

    print_info_schema: bool,

    verbose: bool,

pub fn main() -> AnyhowResult<()> {

    let cli = Cli::parse();

    #[allow(clippy::unwrap_used)]

    if cli.print_info_schema {

        let schema = schema_for!(Context);

        println!("{}", serde_json::to_string_pretty(&schema).unwrap());

        return Ok(());

    }

    let target_family = cli.solver.unwrap_or(SolverFamily::Minion);

    let mut extra_rule_sets: Vec<String> = get_default_rule_sets();

    extra_rule_sets.extend(cli.extra_rule_sets);

    let out_file: Option<File> = match &cli.output {

        None => None,

        Some(pth) => Some(

            File::options()

                .create(true)

                .truncate(true)

                .write(true)

                .open(pth)?,

    let json_log_file = File::options()

        .create(true)

        .append(true)

        .open("conjure_oxide_log.json")?;

    let log_file = File::options()

        .create(true)

        .append(true)

        .open("conjure_oxide.log")?;

    let json_layer = tracing_subscriber::fmt::layer()

        .json()

        .with_writer(Arc::new(json_log_file))

        .with_filter(LevelFilter::TRACE);

    let file_layer = tracing_subscriber::fmt::layer()

        .compact()

        .with_ansi(false)

        .with_writer(Arc::new(log_file))

        .with_filter(LevelFilter::TRACE);

    let default_stderr_level = if cli.verbose {

        LevelFilter::DEBUG

        LevelFilter::WARN

    let env_filter = EnvFilter::builder()

        .with_default_directive(default_stderr_level.into())

        .from_env_lossy();

    let stderr_layer = if cli.verbose {

        Layer::boxed(

            tracing_subscriber::fmt::layer()

                .pretty()

                .with_writer(Arc::new(std::io::stderr()))

                .with_ansi(true)

                .with_filter(env_filter),

        )

        Layer::boxed(

            tracing_subscriber::fmt::layer()

                .compact()

                .with_writer(Arc::new(std::io::stderr()))

                .with_ansi(true)

                .with_filter(env_filter),

        )

    tracing_subscriber::registry()

        .with(json_layer)

        .with(stderr_layer)

        .with(file_layer)

        .init();

    if target_family != SolverFamily::Minion {

        log::error!("Only the Minion solver is currently supported!");

        exit(1);

    }

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

        Ok(rs) => rs,

        Err(e) => {

            log::error!("Error resolving rule sets: {}", e);

            exit(1);

    let pretty_rule_sets = rule_sets

        .iter()

        .map(|rule_set| rule_set.name)

        .collect::<Vec<_>>()

        .join(", ");

    println!("Enabled rule sets: [{}]", pretty_rule_sets);

    log::info!(

        target: "file",

        "Rule sets: {}",

    let rule_priorities = get_rule_priorities(&rule_sets)?;

    let rules_vec = get_rules_vec(&rule_priorities);

    log::info!(target: "file",

         "Rules and priorities: {}",

         rules_vec.iter()

            .map(|rule| format!("{}: {}", rule.name, rule_priorities.get(rule).unwrap_or(&0)))

            .collect::<Vec<_>>()

            .join(", "));

    log::info!(target: "file", "Input file: {}", cli.input_file.display());

    let input_file: &str = cli.input_file.to_str().ok_or(anyhow!(

        "Given input_file could not be converted to a string"

    ))?;

    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()?;

    let conjure_stderr = String::from_utf8(output.stderr)?;

    if !conjure_stderr.is_empty() {

        bail!(conjure_stderr);

    }

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

    let context = Context::new_ptr(

        target_family,

        extra_rule_sets.clone(),

        rules_vec.clone(),

        rule_sets.clone(),

    );

    context.write().unwrap().file_name = Some(cli.input_file.to_str().expect("").into());

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

        log::info!("extra-rule-checks: enabled");

        log::info!("extra-rule-checks: disabled");

    let mut model = model_from_json(&astjson, context.clone())?;

    log::info!(target: "file", "Initial model: {}", json!(model));

    log::info!(target: "file", "Rewriting model...");

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

    let constraints_string = format!("{:?}", model.constraints);

    tracing::info!(%constraints_string, model=%json!(model),"Rewritten model");

    let solutions = get_minion_solutions(model)?; // ToDo we need to properly set the solver adaptor here, not hard code minion

    log::info!(target: "file", "Solutions: {}", minion_solutions_to_json(&solutions));

    let solutions_json = minion_solutions_to_json(&solutions);

    let solutions_str = to_string_pretty(&solutions_json)?;

    match out_file {

        None => {

            println!("Solutions:");

            println!("{}", solutions_str);

        }

        Some(mut outf) => {

            outf.write_all(solutions_str.as_bytes())?;

            println!(

                "Solutions saved to {:?}",

                &cli.output.unwrap().canonicalize()?

    if let Some(path) = cli.info_json_path {

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

        let generated_json = &serde_json::to_value(context_obj)?;

        let pretty_json = serde_json::to_string_pretty(&generated_json)?;

        File::create(path)?.write_all(pretty_json.as_bytes())?;

    }

    Ok(())

}