/// This procedural macro registers a decorated function with `conjure_cp_rules`' global registry, and

/// adds the rule to one or more `RuleSet`'s.

///

/// It may be used in any downstream crate.

/// For more information on registration, see the [`inventory`](https://docs.rs/inventory/latest/inventory/) crate.

///

/// <hr>

///

/// Functions must have the signature `fn(&Expr) -> ApplicationResult`.

/// The created rule will have the same name as the function.

///

/// Intermediary static variables are created to allow for the decentralized registry, with the prefix `CONJURE_GEN_`.

/// Please ensure that other variable names in the same scope do not conflict with these.

///

/// This macro must decorate a function with the given signature.

/// As arguments, it excepts a tuple of 2-tuples in the format:

/// `((<RuleSet name>, <Priority in RuleSet>), ...)`

///

/// <hr>

///

/// For example:

/// ```rust

/// use conjure_cp_core::ast::Expression;

/// use conjure_cp_core::ast::SymbolTable;

/// use conjure_cp_core::rule_engine::{ApplicationError, ApplicationResult, RuleEffect};

/// use conjure_cp_core::rule_engine::register_rule;

///

/// #[register_rule("RuleSetName", 10)]

/// fn identity(expr: &Expression, symbols: &SymbolTable) -> ApplicationResult {

///   Ok(RuleEffect::pure(expr.clone()))

/// }

/// ```

pub use conjure_cp_rule_macros::register_rule;

/// This procedural macro registers a rule set with the global registry.

/// It may be used in any downstream crate.

///

/// For more information on registration, see the [`inventory`](https://docs.rs/inventory/latest/inventory/) crate.

///

/// This macro uses the following syntax:

///

/// ```text

/// register_rule_set!(<RuleSet name>, (<DependencyRuleSet1>, <DependencyRuleSet2>, ...), <SolverFamily>);

/// ```

///

/// # Example

///

/// Register a rule set with no dependencies:

///

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule_set;

/// register_rule_set!("MyRuleSet");

/// ```

///

/// Register a rule set with dependencies:

///

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule_set;

/// register_rule_set!("MyRuleSet", ("DependencyRuleSet", "AnotherRuleSet"));

/// ```

///

/// Register a rule set for a specific solver family or families:

///

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule_set;

/// use conjure_cp_core::settings::SolverFamily;

/// register_rule_set!("MyRuleSet", (), |f: &SolverFamily| matches!(f, SolverFamily::Minion));

/// register_rule_set!("AnotherRuleSet", (), |f: &SolverFamily| matches!(f, SolverFamily::Minion | SolverFamily::Sat));

/// ```

#[doc(inline)]

pub use conjure_cp_rule_macros::register_rule_set;

pub use resolve_rules::{RuleData, get_rules, get_rules_grouped, resolve_rule_sets};

pub use rewrite::rewrite_model;

pub use rewriter_common::RewriteError;

pub use rule::{

    ApplicationError, ApplicationResult, AtomKind, Rule, RuleEffect, RuleFailureInvalidation,

    RuleFn, RulePrefilter,

};

pub use rule_set::RuleSet;

mod expression_zipper;

#[doc(hidden)]

pub use expression_zipper::ExpressionZipper;

use crate::{

    Model,

    settings::{Rewriter, SolverFamily},

};

mod encoding_selection;

mod resolve_rules;

mod rewrite;

mod rewriter_common;

mod rule;

mod rule_set;

inventory::collect!(&'static Rule<'static>);

inventory::collect!(&'static RuleSet<'static>);

pub mod _dependencies {

    pub use inventory;

}

/// Returns a copied `Vec` of all rules registered with the `register_rule` macro.

///

/// Rules are not guaranteed to be in any particular order.

///

/// # Example

/// ```rust

/// # use conjure_cp_core::rule_engine::{ApplicationResult, RuleEffect, get_all_rules};

/// # use conjure_cp_core::ast::Expression;

/// # use conjure_cp_core::ast::SymbolTable;

/// # use conjure_cp_core::rule_engine::register_rule;

///

/// #[register_rule]

/// fn identity(expr: &Expression, symbols: &SymbolTable) -> ApplicationResult {

///   Ok(RuleEffect::pure(expr.clone()))

/// }

///

/// fn main() {

///   println!("Rules: {:?}", get_all_rules());

/// }

/// ```

///

/// This will print (if no other rules are registered):

/// ```text

///   Rules: [Rule { name: "identity", application: MEM }]

/// ```

/// Where `MEM` is the memory address of the `identity` function.

/// Get a rule by name.

/// Returns the rule with the given name or None if it doesn't exist.

///

/// # Example

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule;

/// use conjure_cp_core::rule_engine::{Rule, ApplicationResult, RuleEffect, get_rule_by_name};

/// use conjure_cp_core::ast::Expression;

/// use conjure_cp_core::ast::SymbolTable;

///

/// #[register_rule]

/// fn identity(expr: &Expression, symbols: &SymbolTable) -> ApplicationResult {

///  Ok(RuleEffect::pure(expr.clone()))

/// }

///

/// fn main() {

/// println!("Rule: {:?}", get_rule_by_name("identity"));

/// }

/// ```

///

/// This will print:

/// ```text

/// Rule: Some(Rule { name: "identity", application: MEM })

/// ```

        .copied()

/// Get all rule sets

/// Returns a `Vec` of static references to all rule sets registered with the `register_rule_set` macro.

/// Rule sets are not guaranteed to be in any particular order.

///

/// # Example

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule_set;

/// use conjure_cp_core::rule_engine::get_all_rule_sets;

///

/// register_rule_set!("MyRuleSet", ("AnotherRuleSet"));

/// register_rule_set!("AnotherRuleSet", ());

///

/// println!("Rule sets: {:?}", get_all_rule_sets());

/// ```

///

/// This will print (if no other rule sets are registered):

/// ```text

/// Rule sets: [

///   RuleSet { name: "MyRuleSet", rules: OnceLock { state: Uninitialized }, dependencies: ["AnotherRuleSet"] },

///   RuleSet { name: "AnotherRuleSet", rules: OnceLock { state: Uninitialized }, dependencies: [] }

/// ]

/// ```

///

/// Rewrites a model using the supplied rewriter configuration.

/// Get a rule set by name.

/// Returns the rule set with the given name or None if it doesn't exist.

///

/// # Example

/// ```rust

/// use conjure_cp_core::rule_engine::register_rule_set;

/// use conjure_cp_core::rule_engine::get_rule_set_by_name;

///

/// register_rule_set!("MyRuleSet", ("DependencyRuleSet", "AnotherRuleSet"));

///

/// println!("Rule set: {:?}", get_rule_set_by_name("MyRuleSet"));

/// ```

///

/// This will print:

/// ```text

/// Rule set: Some(RuleSet { name: "MyRuleSet", rules: OnceLock { state: Uninitialized }, dependencies: ["DependencyRuleSet", "AnotherRuleSet"] })

/// ```

        .copied()

/// Get all rule sets for a given solver family.

/// Returns a `Vec` of static references to all rule sets that are applicable to the given solver family.

/// Rule sets are not guaranteed to be in any particular order.

///

/// # Example

///

/// ```rust

/// use conjure_cp_core::settings::SolverFamily;

/// use conjure_cp_core::rule_engine::{get_rule_sets_for_solver_family, register_rule_set};

///

/// register_rule_set!("CNF", (), |f: &SolverFamily| matches!(f, SolverFamily::Sat));

/// register_rule_set!("MinionOnly", (), |f: &SolverFamily| matches!(f, SolverFamily::Minion));

///

/// let rule_sets = get_rule_sets_for_solver_family(SolverFamily::Sat);

/// assert!(rule_sets.iter().any(|rule_set| rule_set.name == "CNF"));

/// assert!(!rule_sets.iter().any(|rule_set| rule_set.name == "MinionOnly"));

/// ```

        .copied()

        .collect()