pub fn assert_eq_any_order<T: Eq + Hash + Debug + Clone>(a: &Vec<Vec<T>>, b: &Vec<Vec<T>>) {

    assert_eq!(a.len(), b.len());

    let mut a_rows: Vec<HashSet<T>> = Vec::new();

    for row in a {

        let hash_row = to_set(row);

        a_rows.push(hash_row);

    }

    let mut b_rows: Vec<HashSet<T>> = Vec::new();

    for row in b {

        let hash_row = to_set(row);

        b_rows.push(hash_row);

    }

    println!("{:?},{:?}", a_rows, b_rows);

    for row in a_rows {

        assert!(b_rows.contains(&row));

}

        std::fs::copy(

            format!("{path}/{test_name}.generated-{test_stage}.serialised.json"),

            format!("{path}/{test_name}.expected-{test_stage}.serialised.json"),

        )?;

pub fn save_stats_json(

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

    path: &str,

    test_name: &str,

) -> Result<(), std::io::Error> {

    #[allow(clippy::unwrap_used)]

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

    let generated_json = sort_json_object(&serde_json::to_value(stats)?, false);

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

    File::create(format!("{path}/{test_name}-stats.json"))?

        .write_all(generated_json_str.as_bytes())?;

    Ok(())

}

pub fn minion_solutions_from_json(

    serialized: &str,

) -> Result<Vec<HashMap<Name, Literal>>, anyhow::Error> {

    let json: JsonValue = serde_json::from_str(serialized)?;

    let json_array = json

        .as_array()

        .ok_or(Error::Parse("Invalid JSON".to_owned()))?;

    let mut solutions = Vec::new();

    for solution in json_array {

        let mut sol = HashMap::new();

        let solution = solution

            .as_object()

            .ok_or(Error::Parse("Invalid JSON".to_owned()))?;

        for (var_name, constant) in solution {

            let constant = match constant {

                JsonValue::Number(n) => {

                    let n = n

                        .as_i64()

                        .ok_or(Error::Parse("Invalid integer".to_owned()))?;

                    Literal::Int(n as i32)

                JsonValue::Bool(b) => Literal::Bool(*b),

                _ => return Err(Error::Parse("Invalid constant".to_owned()).into()),

            sol.insert(UserName(var_name.into()), constant);

        solutions.push(sol);

    Ok(solutions)

}

pub fn save_minion_solutions_json(

    solutions: &Vec<HashMap<Name, Literal>>,

    path: &str,

    test_name: &str,

    accept: bool,

) -> Result<JsonValue, std::io::Error> {

    let json_solutions = minion_solutions_to_json(solutions);

    let generated_json_str = serde_json::to_string_pretty(&json_solutions)?;

    File::create(format!(

        "{path}/{test_name}.generated-minion.solutions.json"

    ))?

    .write_all(generated_json_str.as_bytes())?;

    if accept {

        std::fs::copy(

            format!("{path}/{test_name}.generated-minion.solutions.json"),

            format!("{path}/{test_name}.expected-minion.solutions.json"),

        )?;

    }

    Ok(json_solutions)

}

pub fn read_minion_solutions_json(

    path: &str,

    test_name: &str,

    prefix: &str,

) -> Result<JsonValue, anyhow::Error> {

    let expected_json_str =

        std::fs::read_to_string(format!("{path}/{test_name}.{prefix}-minion.solutions.json"))?;

    let expected_solutions: JsonValue =

        sort_json_object(&serde_json::from_str(&expected_json_str)?, true);

    Ok(expected_solutions)

}

pub fn read_rule_trace(

    path: &str,

    test_name: &str,

    prefix: &str,

    accept: bool,

) -> Result<Vec<String>, std::io::Error> {

    let filename = format!("{path}/{test_name}-{prefix}-rule-trace.json");

    let mut rules_trace: Vec<String> = read_to_string(&filename)

        .unwrap()

        .lines()

        .map(String::from)

        .collect();

    //only count the number of rule in generated file (assumming the expected version already has that line and it is correct)

    if prefix == "generated" {

        let rule_count = rules_trace.len();

        let count_message = json!({

            "message": " Number of rules applied",

            "count": rule_count

        });

        let count_message_string = serde_json::to_string(&count_message)?;

        rules_trace.push(count_message_string.clone());

        let mut file = OpenOptions::new()

            .write(true)

            .truncate(true) // Overwrite the file with updated content

            .open(&filename)?;

        writeln!(file, "{}", rules_trace.join("\n"))?;

    }

    if accept {

        std::fs::copy(

            format!("{path}/{test_name}-generated-rule-trace.json"),

            format!("{path}/{test_name}-expected-rule-trace.json"),

        )?;

    }

    Ok(rules_trace)

}