use crate::{

    ast::Metadata,

    ast::{Domain, Moo, Range, ReturnType},

    bug, bug_assert, matrix_expr,

};

use super::{Expression, Literal, Typeable};

use serde::{Deserialize, Serialize};

/// The possible kinds of associative-commutative (AC) operator.

///

/// AC operators take a single vector as input and are commonly used alongside comprehensions.

///

/// `Min`/`Max` are included here for the sole purpose of tagging a comprehension's

/// [`skip_operator`](super::comprehension::Comprehension::skip_operator) so that a symbolic guard

/// inside `min([... | ...])`/`max([... | ...])` can be lowered correctly by the native

/// comprehension expander -- unlike `And`/`Or`/`Sum`/`Product`, they have no universal identity

/// element (the "safe value to substitute for a guarded-out element" depends on the element's own

/// domain), so [`identity`](Self::identity) is intentionally unreachable for them; callers that

/// might see a `Min`/`Max` operator must check for that first (see

/// `expand_native.rs`'s guard on the identity-dropping optimisation for the only current example).

/// They are deliberately not wired into `TryFrom<&Expression>` or the AC-comprehension merge/

/// via-solver machinery, which only ever handles the four true AC operators.

#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]

pub enum ACOperatorKind {

    And,

    Or,

    Product,

    Sum,

    Min,

    Max,

}

impl ACOperatorKind {

    /// Creates a new [Expression] of this AC operator kind with the given child expression.

    ///

    /// The child expression given should be of type matrix.

        bug_assert!(

            "The child expression given to ACOperatorKind::to_expression should be of type matrix."

        );

        }

    /// Returns the identity element of this operation.

    ///

    /// # Example

    ///

    /// ```

    /// use conjure_cp_core::ast::{ac_operators::ACOperatorKind,Literal};

    ///

    /// let identity = ACOperatorKind::And.identity();

    /// assert_eq!(identity,Literal::Bool(true));

    /// ```

    ///

    /// # Panics

    ///

    /// `Min`/`Max` have no universal identity element -- see the type-level doc comment. Callers

    /// must not call this for those two variants.

            ACOperatorKind::Min | ACOperatorKind::Max => {

                bug!("ACOperatorKind::{self:?} has no universal identity element")

            }

        }

    /// Given some guard and tail expressions, constructs the skipping operator for this operation.

    ///

    /// The skipping operator is operator that takes some boolean guard expression b and some tail

    /// expression x. If b is true, then it evaluates to x, otherwise it evaluates to the identity

    /// element.

    ///

    /// # Usage

    ///

    /// This can be used to add guards to elements of AC operations. In the example model below, we

    /// only want to multiply y*z by 2 if multiplyByTwo is true:

    ///

    /// ```plain

    /// find multiplyByTwo: bool

    /// find x: int(1..5)

    /// find y: int(1..5)

    /// find z: int(1..5)

    ///

    /// such that

    ///  

    /// x = product([y,z,[1,x;int(0..1)][toInt(b)]])

    /// ```

    ///

    /// `[1,x;int(0..1)][toInt(b)]` is the skipping operator for product.

    ///

    /// This method constructs the skipping operator, substituting in the given expressions for b

    /// and x.

        bug_assert!(

            "The guard expression in a skipping operation should be type boolean."

        );

            ACOperatorKind::And => {

                bug_assert!(

                    "The tail expression in an and skipping operation should be type boolean."

                );

            }

            ACOperatorKind::Or => {

                bug_assert!(

                    "The tail expression in an or skipping operation should be type boolean."

                );

            }

            ACOperatorKind::Product => {

                bug_assert!(

                    "The tail expression in a product skipping operation should be type int."

                );

            }

            ACOperatorKind::Sum => {

                bug_assert!(

                    "The tail expression in a sum skipping operation should be type int."

                );

            }

            ACOperatorKind::Min | ACOperatorKind::Max => {

                bug!(

                     cannot build a skip operation for it -- use make_min_max_skip_operation instead, \

                     which takes an explicit skip value"

                )

            }

        }

    /// The min/max equivalent of [`make_skip_operation`](Self::make_skip_operation): `self` must

    /// be `Min` or `Max`. Unlike the four true AC operators, min/max have no value that's always

    /// safe to substitute for a guarded-out element -- callers must supply one themselves (`skip_value`),

    /// since this method has no way to know it: by the time a per-branch skip operation is being

    /// built, `tail_expr` is already the branch-specific (and so potentially far too narrow)

    /// result, not the comprehension's general return-expression domain the skip value should

    /// come from. Any domain bound safe for every element being aggregated works (e.g. the

    /// element's declared domain's max, for `min`, or min, for `max`) -- including it can never

    /// change a min/max computed over at least one *included* real element, since it is never more

    /// extreme than any value the element could actually take.

        bug_assert!(

            "make_min_max_skip_operation is only valid for ACOperatorKind::Min/Max."

        );

        bug_assert!(

            "The guard expression in a skipping operation should be type boolean."

        );

        bug_assert!(

            "The tail expression in a min/max skipping operation should be type int."

        );

    /// Gives the return type of the operator, and the return types its elements should be.

            ACOperatorKind::Product

            | ACOperatorKind::Sum

            | ACOperatorKind::Min

        }

}

impl TryFrom<&Expression> for ACOperatorKind {

    type Error = ();

        }

}

impl TryFrom<Expression> for ACOperatorKind {

    type Error = ();

}

impl TryFrom<Box<Expression>> for ACOperatorKind {

    type Error = ();

}