use std::collections::{HashMap, HashSet};

use std::fmt::{Display, Formatter};

use std::hash::Hash;

use std::sync::OnceLock;

use log::warn;

use crate::rule_engine::{get_rule_set_by_name, get_rules, Rule};

use crate::solver::SolverFamily;

/// A structure representing a set of rules with a name, priority, and dependencies.

///

/// `RuleSet` is a way to group related rules together under a single name.

/// You can think of it like a list of rules that belong to the same category.

/// Each `RuleSet` can also have a number that tells it what order it should run in compared to other `RuleSet` instances.

/// Additionally, a `RuleSet` can depend on other `RuleSet` instances, meaning it needs them to run first.

///

/// To make things efficient, `RuleSet` only figures out its rules and dependencies the first time they're needed,

/// and then it remembers them so it doesn't have to do the work again.

///

/// # Fields

/// - `name`: The name of the rule set.

/// - `order`: A number that decides the order in which this `RuleSet` should be applied.

/// If two `RuleSet` instances have the same rule but with different priorities,

/// the one with the higher `order` number will be the one that is used.

/// - `rules`: A lazily initialized map of rules to their priorities.

/// - `dependency_rs_names`: The names of the rule sets that this rule set depends on.

/// - `dependencies`: A lazily initialized set of `RuleSet` dependencies.

/// - `solver_families`: The solver families that this rule set applies to.

#[derive(Clone, Debug)]

pub struct RuleSet<'a> {

    /// The name of the rule set.

    pub name: &'a str,

    /// Order of the RuleSet. Used to establish a consistent order of operations when resolving rules.

    /// If two RuleSets overlap (contain the same rule but with different priorities), the RuleSet with the higher order will be used as the source of truth.

    pub order: u16,

    /// A map of rules to their priorities. This will be lazily initialized at runtime.

    rules: OnceLock<HashMap<&'a Rule<'a>, u16>>,

    /// The names of the rule sets that this rule set depends on.

    dependency_rs_names: &'a [&'a str],

    dependencies: OnceLock<HashSet<&'a RuleSet<'a>>>,

    /// The solver families that this rule set applies to.

    pub solver_families: &'a [SolverFamily],

}

impl<'a> RuleSet<'a> {

    /// Get the rules of this rule set, evaluating them lazily if necessary

    /// Returns a `&HashMap<&Rule, u16>` where the key is the rule and the value is the priority of the rule.

            None => {

            }

        }

    /// Get the dependencies of this rule set, evaluating them lazily if necessary

    /// Returns a `&HashSet<&RuleSet>` of the rule sets that this rule set depends on.

    #[allow(clippy::mutable_key_type)] // RuleSet is 'static so it's fine

            None => {

            }

        }

    /// Get the dependencies of this rule set, including itself

    #[allow(clippy::mutable_key_type)] // RuleSet is 'static so it's fine

    /// Resolve the rules of this rule set ("reverse the arrows")

            }

        }

    /// Recursively resolve the dependencies of this rule set.

    #[allow(clippy::mutable_key_type)] // RuleSet is 'static so it's fine

                None => {

                    );

                }

                }

            }

        }

}

impl PartialEq for RuleSet<'_> {

}

impl Eq for RuleSet<'_> {}

impl Hash for RuleSet<'_> {

}

impl Display for RuleSet<'_> {

}