use std::fmt::Display;

use super::categories::{Category, CategoryOf};

use crate::representation::Representation;

use conjure_cp_core::ast::DomainPtr;

use conjure_cp_core::ast::domains::HasDomain;

use derivative::Derivative;

use serde::{Deserialize, Serialize};

/// Represents a decision variable within a computational model.

///

/// A `DecisionVariable` has a domain that defines the set of values it can take. The domain could be:

/// - A boolean domain, meaning the variable can only be `true` or `false`.

/// - An integer domain, meaning the variable can only take specific integer values or a range of integers.

///

/// # Fields

/// - `domain`:

///   - Type: `Domain`

///   - Represents the set of possible values that this decision variable can assume. The domain can be a range of integers

///     (IntDomain) or a boolean domain (BoolDomain).

///

/// # Example

///

/// use crate::ast::domains::{DecisionVariable, Domain, Range};

///

/// let bool_var = DecisionVariable::new(Domain::BoolDomain);

/// let int_var = DecisionVariable::new(Domain::IntDomain(vec![Range::Bounded(1, 10)]));

///

/// println!("Boolean Variable: {}", bool_var);

/// println!("Integer Variable: {}", int_var);

#[derive(Clone, Debug, Serialize, Deserialize, Derivative)]

#[derivative(Hash, PartialEq, Eq)]

pub struct DecisionVariable {

    pub domain: DomainPtr,

    // use this through [`Declaration`] - in the future, this probably will be stored in

    // declaration / domain, not here.

    #[serde(skip)]

    #[derivative(Hash = "ignore", PartialEq = "ignore")]

    pub(super) representations: Vec<Vec<Box<dyn Representation>>>,

    /// Category - should be quantified or decision variable

    pub(super) category: Category,

}

impl DecisionVariable {

            "category of a DecisionVariable should be quantified or decision"

        );

}

impl CategoryOf for DecisionVariable {

}

impl HasDomain for DecisionVariable {

}

impl Display for DecisionVariable {

}